Unusual behavior with C++ vectors - c++

Question

struct Base{
int hp = 1000;
virtual ~Base()
{
std::cout << "Base destructor\n";
}
};
struct Child : Base {
int hp = 100;
virtual ~Child()
{
std::cout << "Child destructor\n";
}
};
int main()
{
std::vector<Base*>vct;
for(int x=0;x<25;x++)
{
vct.push_back(new Child);
}
std::cout << vct[3]->hp;
return 0;
}
I have written this program, which creates 25 objects of type Child, yet when run, both the destructors of the child and base class are called, which would imply that the 'new child' call would create an instance of both the child, and the base class. Why?
Furthermore, trying to access the int "hp" of any of the members of the vector, always returns 1000, not 100, which indicates that all the vector members are of type Base, not of type Child.
So in short, what do I need to do to 1. only create Child objects, not Base(even having the Base class as an abstract class still, somehow, seems to create objects of it) 2. Have all the members/elements of the vector to be of the child class, when the type of the vector is Base*

Answer 1

This is exactly how C++ inheritance works. Even if you didn't explicitly define a constructor, the parent class's default constructor still runs. In this case, the default constructors are mostly a no-op save for the member initialization of hp in both.
Both Child destructor and Base destructor get printed because you declared your destructor (correctly) as virtual. However, you aren't explicitly deleting any instance of objects you are allocating via new, so I'm not sure how you are seeing any print statements at all.
The hp in Child shadows the hp in Base, but member variables are not virtual. So when you access hp via Base class pointer, you get the Base class member. If you want to have the derived class access to hp, mark hp as protected in Base, and set in constructor in derived. In you case, everything is a struct, so all members are already public.
struct Base{
int hp = 1000;
virtual ~Base()
{
std::cout << "Base destructor\n";
}
};
struct Child : Base {
Child()
{
hp = 100; // Base constructor has already run, so we override here
}
virtual ~Child()
{
std::cout << "Child destructor\n";
}
};
int main()
{
std::vector<Base*>vct;
for(int x=0;x<25;x++)
{
vct.push_back(new Child);
}
std::cout << vct[3]->hp;
// let's delete explicitly and avoid the leak.
for(int x=0;x<25;x++)
{
delete vec[x];
vec[x] = nullptr; // not necessary, but is a good practice
}
return 0;
}