Never Redefine an inherited nonvirtual function

[Phil15]

Hi, recently I was wondering what happens underneath during compile time
when running the code below.

why is the function of class B not called?
Is it because you have two clashing definitions and one overrides the other?

I thought "A * ptr" was just a declaration
why is it when I allocate a B object and call it`s function
it even knows about the function of A. What do I read to
understand more?

  #include <iostream>


class A {
public:


	void foo()
	{
		std::cout << "This is A \n";
	}


};


class B : public A{
public:

	

	void foo()
	{
		std::cout << "This is B \n";
	}



};

int main()
{

	A * ptr = new B();

	ptr->foo();
	system("pause");

}

Many thanks,
Phil

[Peter87]

The compiler only looks at the type of the pointer when deciding which function to call.

ptr is a A* so ptr->foo() will call A::foo().

[Phil15]

Ok then why is the constructor of B called in this case?

 #include <iostream>


class A {
public:

	A()
	{
				std::cout << "This is A CTR \n";
	}

	void foo()
	{
		std::cout << "This is A \n";
	}

};


class B : public A{
public:

	B()
	{
				std::cout << "This is B CTR \n";
	}

	void foo()
	{
		std::cout << "This is B \n";
	}



};

int main()
{

	A * ptr = new B();

	ptr->foo();
	system("pause");

}

[keskiverto]

new B(); is explicit call to constructor. It returns address of type B object.

You then store the address into ptr, which is pointer-to-A. Implicit conversion from B* ta A* is possible, because B is-a A by inheritance.

[Phil15]

That`s insightful thank you both,

Last question why does this work, should it not throw a compiler error
due to implicitly converting float to int?

 #include <iostream>


class A {
public:

	 A()
	{
				std::cout << "This is A CTR \n";
	}
	 
	void foo()
	{
		std::cout << "This is A \n";
	}

};


 class B : public A{
public:

	explicit B(int a)
	{
				std::cout << "This is value A = " << a << std::endl;
	}

	explicit B()
	{
				std::cout << "This is B CTR \n";
	}

	void foo()
	{
		std::cout << "This is B \n";
	}



};

int main()
{

	A * ptr = new B(1.5f);

	ptr->foo();
	system("pause");

}

[Peter87]

In C++ implicitly conversion from float to int is allowed. Some compilers could give you a warning though.

[JLBorges]

void foo( int ) {}

int main()
{
    foo( 1.2f ) ; // fine: implicit conversion from float to int
    
    foo( { 1.2f } ) ; // *** error: narrowing conversion

    const unsigned long long a = 1234 ;
    foo( {a} ) ; // fine: compile-time constant within the range of 'int', not narrowing

    unsigned long long b = 1234 ;
    foo( {b} ) ; // *** error: narrowing conversion
}

See: http://www.stroustrup.com/C++11FAQ.html#narrowing

[Phil15]

All clear.
Thanks everyone !