list of pointer to base class-understand code - c++

Question

I am training to my exam in c++ and I don't understand why the code display only print function of the base class (also after I debug the code) and never go to the print of derived class.
Can you explain me why in a simple way, and does there is some issue I can do in order to also display the print function of derived class only by edit a few line of code.
Let say the number that the program generate are: 1 67 0 69 0 0 58 78.
class A
{
int a;
public:
A(int x):a(x){}
void print() { cout << "a=" << a << ' '; }
};
class B:public A
{
int b;
public:
B(int x,int y) :A(x),b(y) {}
void print() { A::print(); cout << "b=" << b << ' '; }
};
int main(){
list<A*> lst;
for (int i = 0; i < 3; i++)
if(rand()%2)
lst.push_back(new A(rand() % 100));
else
lst.push_back(new B(rand() % 100,rand()%100));
for (list<A*>::iterator it = lst.begin(); it != lst.end(); it++)
(*it)->print();
}

Answer 1

You need to declare print() virtual in order for polymorphism to work.
Here is your example with suggested formatting improvements,
#include <iostream>
#include <list>
class A{
int a;
public:
A(int x):a(x){}
virtual void print() { std::cout << "a=" << a << ' '; }
};
class B:public A{
int b;
public:
B(int x,int y) :A(x),b(y) {}
void print() override { A::print(); std::cout << "b=" << b << ' '; }
};
int main(){
std::list<A*> lst;
for (int i = 0; i < 30; i++) {
if(rand()%2) {
lst.push_back(new A(rand() % 100));
} else {
lst.push_back(new B(rand() % 100,rand()%100));
}
}
for (std::list<A*>::iterator it = lst.begin(); it != lst.end(); it++) {
(*it)->print();
}
}
I increased the number of printed elements, because in these settings I wasn't getting a single b. This said:
You need to seed your code with srand if you don't want to get the same numbers over and over again (and you need to seed it only once per program).
If possible, you should use the new random number generation functionality available from C++11 on.
override is optional, but very encouraged, it clearly signals that the function was virtual and re-implemented.
Most importantly you need to free the memory you allocated with new (using delete), or better yet, use the approach in #TedLyngmo answer (smart pointers)

Answer 2

In order to make use of dynamic dispatch, you need to make A::print() virtual. You also need to make A's destructor virtual to be able to delete objects through the base class pointer.
Since you currently do not delete any objects (but instead leak all A's and Bs) I suggest that you make use of a smart pointer, std::unique_ptr<A>, that will clean up when the std::list is destroyed.
Example:
#include <iostream>
#include <list>
#include <memory> // std::unique_ptr
class A {
int a;
public:
A(int x) : a(x) {}
virtual ~A() = default; // virtual destructor
virtual void print() { std::cout << "a=" << a << ' '; }
};
class B : public A {
int b;
public:
B(int x, int y) : A(x), b(y) {}
void print() override {
A::print();
std::cout << "b=" << b << ' ';
}
};
int main() {
std::list<std::unique_ptr<A>> lst; // use of smart pointer
for(int i = 0; i < 30; i++) {
if(rand() % 2) {
lst.emplace_back(std::make_unique<A>(rand() % 100));
} else {
lst.emplace_back(std::make_unique<B>(rand() % 100, rand() % 100));
}
}
for(auto it = lst.begin(); it != lst.end(); it++) {
(*it)->print();
}
// Simpler loop: A range-based for loop:
// for(auto& ptr : lst) ptr->print();
}