bad downcasting in a derived class

I am the following structure. I minimized to the shortest possible way to reproduce the error:

I have two level of derived class. I don't have any compilation error. The error is at the runtime:

> Unhandled exception at 0x00007FFF1021CF19 in base.exe: Microsoft C++
> exception: std::__non_rtti_object at memory location
> 0x00000022B9BDF458.

Is there any suggection?

#include <iostream>
#include <vector>
#include <memory>

class Base {
public:
    int a;
    Base(int _a) : a(_a) {};
    virtual void print() = 0;
};

class derivedA : public Base
{
public:
    derivedA(int _a) : Base(_a) {};
    void print() { std::cout << "dA" << std::endl; }
};

class derivedB : public derivedA
{
public:
    derivedB(int _a) : derivedA(_a) {};
    void print() { std::cout << "dB" << std::endl; }
};

void construct(std::vector<derivedA*>& da_vec) {
    da_vec.push_back(std::unique_ptr<derivedA>(new derivedB(4)).get());
}

void func(derivedA& da)
{
    derivedB& db = dynamic_cast<derivedB&>(da);
    db.print();
}

int main()
{
    std::vector<derivedA*> da_vec;
    construct(da_vec);
    for (auto& da : da_vec)
        func(*da);
}

• When you push_back the derivedB base class pointer, you store a dangling pointer.

  da_vec.push_back(std::unique_ptr<derivedA>(new derivedB(4)).get());
  

  The unique_ptr<derivedA> is destroyed at the end of the expression, so the pointer you got from .get() is "dangling", which means that it should not be dereferenced. The object it pointed at is gone.

To solve that, I suggest that you instead store std::unique_ptr<derivedA> in your vector. You also do not need to cast to derivedB& before calling the overridden print method. That's what polymorphism solves for you automatically.

Example:

void construct(std::vector<std::unique_ptr<derivedA>>& da_vec) {
    da_vec.push_back(std::make_unique<derivedB>(4));
}

void func(derivedA& da) {
    //derivedB& db = dynamic_cast<derivedB&>(da);
    da.print();
}

int main() {
    std::vector<std::unique_ptr<derivedA>> da_vec;
    construct(da_vec);
    for (auto& da : da_vec)
        func(*da);
}

Demo

Note: I made the Base destructor virtual too which is necessary in order to destroy objects via a base class pointer in order for all the destructors to be called (from most derrived to the base).

I also marked the overridden methods with override which is not strictly necesssary, but helps when reading the code - and it will also give you a compilation error in case you think you override something, but actually isn't.