Use a children method c++ - c++

Question

I have those objects:
class A{
public:
void print();
}
class B : public A{
public:
void print();
}
class C : public A{
public:
void print();
}
The function print:
void A::print(){
cout << "A" << endl;
}
void B::print(){
cout << "B" << endl;
}
void C::print(){
cout << "C" << endl;
}
Now I have a vector of A objects which can contain A B or C
for(unsigned int i = 0; i<m_vA.size(); i++)
{
cout << m_vA[i]->print() << endl;
}
But each time the function returns A even if this is a B or C object
Thanks for the help

Answer 1

You do not override the function. To do so, use "virtual" keyword while declaring this function in A class.

Answer 2

You forgot to make the member function virtual.

Answer 3

The short answer is: use virtual as the other answers indicate, so that you override the function, instead of hiding it.
Here's an excerpt from Herb Sutter's Exceptional C++ - Item 21: Overriding Virtual Functions which explains in more detail what is going on with your code:
It's important to differentiate between three common terms:
To overload a function f() means to provide another function with the same name f() in the same scope but with different
parameter types. When f() is actually called, the compiler will try
to pick the best match based on the actual parameters that are
supplied.
To override a virtual function f() means to provide another function with the same name f() and the same parameter types in a
derived class.
To hide a function f() in an enclosing scope (base class, outer class, or namespace) means to provide another function with the same
name f() in an inner scope (derived class, nested class, or
namespace), which will hide the same function name in an enclosing
scope.
Because your various print functions are in nested scopes, and because you have not provided the virtual keyword, each function is hiding the functions of the same name in the base class(es):
class A{
public:
void print();
}
class B : public A{
public:
void print(); // Hides A::print()
}
class C : public A{
public:
void print(); // Hides A::print() and B::print()
}
So, when the compiler performs name resolution, it will look within the current scope (which is the class definition for the type from which you have called the function) and it will stop there because it will find a non-virtual function with the name print.

Answer 4

Polymorphism requires the use of the virtual keyword to declare that the method should be stored in a virtual table (vtable), and its implementation looked-up at runtime.
Note also that your class definitions need semicolons after the closing brackets.
class A
{
public:
virtual void print()
{
cout << "A" << endl;
}
};
class B : public A
{
public:
virtual void print() override
{
cout << "B" << endl;
}
};
class C : public A
{
public:
virtual void print() override
{
cout << "C" << endl;
}
};
On a side note, the virtual keyword in the derived classes is not necessary (it's implicitly added in derived classes if the base class function is declared virtual), but good to use for readability and to avoid potential issues with the odd compiler that requires it. The override identifier is also not necessary, but forces the compiler to check that you are in fact overriding a virtual function that exists in the superclass. (I think override is only available in C++11).