从基类的shared_ptr获取对象

Question

Can I achieve regular polymorphism through smart_ptr in c++?

I have these 2 structs:

struct Base{... // methods and variables
};

struct D: Base{... // inherited methods and variable plus a few new methods
};

And these 2 structs will be used like this:

typedef msm::back::state_machine<Base>  ESM; //(Base_namespace::ESM)
typedef msm::back::state_machine<D>  ESM; //(Derived_namespace::ESM)
//The state_machine is from boost lib.
//They (ESM and ESM) are in different namespaces, so no problem using them

And in another 2 classes, I have this:

Derived_namespace{
class derived_sth: public Base_namespace::sth
{
    public:
    //This method is used to assgin the m_base a share_ptr of type base ESM
    void setPtr(const std::shared_ptr<Derived_namespace::ESM> sm){
        m_base = std::dynamic_pointer_cast<Base_namespace::ESM>(sm);
    }
};
}

Base_namespace{
class sth
{
    public:
    void Base_namespace::onStart()
    {
        //!!!!!!!!
        //Here comes the problem, the variable sm turns out 
        //to be null, or some value that causes the following
        //if() statement to be false;
        //So how can I get the correct result?
        //!!!!!!!!
        std::shared_ptr<Base_namespace::ESM> sm = m_base.lock();
        if (sm)
        {
            sm->start();
        }
    }
    protected:
        std::weak_ptr<Base_namespace::ESM>  m_base;
    ...
};
}

The method setPtr() will be called with type std::shared_ptr<Derived_namespace::ESM> , then onStart() . So the m_base should not be null when onStart() gets called.

The specific question is in the comment. Any help is appreciated and I also would like to know the general good practice when it comes to polymorphism with smart pointers. Thanks!!

Answer 1

Polymorphism with smart pointers works the same way that polymorphism with regular pointers does.

For example, let's say I have a class Animal with a virtual speak() method.

class Animal {
   public:
    virtual ~Animal() = default;
    virtual void speak() {
        std::cout << "I am an animal.\n"; 
    }
};

I can override this method for dogs, cats, and cows:

class Dog : Animal {
   public: 
    void speak() override {
        std::cout << "Woof.\n";
    }
};

class Cat : Animal {
   public:
    void speak() override {
        std::cout << "Meow.\n";
    }
};

class Cow : Animal {
   public:
    void speak() override {
        std::cout << "Moo.\n";
    }
};

Now that I have this, I can write a function that makes the animal speak twice:

void speakTwice(Animal& animal) {
    animal.speak();
    animal.speak();
}

Because speak is virtual, this will call the correct version of speak :

Dog dog;
Cat cat;
Cow cow; 
// Prints:
// > Woof.
// > Woof.
speakTwice(dog); 
// Prints:
// > Meow.
// > Meow.             
speakTwice(cat);
// Prints:
// > Moo.
// > Moo.
speakTwice(cow); 

This only works because speak is virtual. And it works the same way with smart pointers, except using ->

void speakTwice(std::shared_ptr<Animal> animal) {
    animal->speak();
    animal->speak();
}

Using this with weak_ptr :

This is very straight-forward too, and the below example will tell you if the pointer was null or expired.

void speakTwice(std::weak_ptr<Animal> const& animal) {
    if(animal.expired()) {
        std::cerr << "Animal was expired.\n";
        return;
    }
    auto ptr = animal.lock();
    if(ptr) {
        ptr->speak();
        ptr->speak();
    } else {
        std::cerr << "Animal was null.\n"; 
    }
}
}

Why your code runs into issues

You didn't provide enough code for us to figure out the issue, although these are some possibilities:

• You didn't assign anything to m_base , so it's null when you lock it
• Maybe you forgot to make start() virtual? IDK
• We really don't have enough info to solve the problem

Yeah.