具有模板化类和动态调度的C ++ shared_pointer

Question

I have a C++ code where I try to create a shared_pointer on a derived class. When the shared_pointer is created, the dynamic dispatch stops working.

My code:

#include <iostream>
#include <memory>

using namespace std;

template <typename T>
class Base
{
public:
    virtual void print()
    {
        cout << "Print from Base" << endl;
    }

};

template <typename T>
class Child : public Base<T>
{
public:
    virtual void print()
    {
        cout << "Print from Child" << endl;
    }
};

template <typename T>
class TestClass: public Base<T>
{
public:
    TestClass<T> (Base<T> &b)
    {
        b.print();
        shared_ptr<Base<T>> sptr = make_shared<Base<T>> (b);
        sptr->print();
    }
};

int main()
{
    Child<int> child;
    TestClass<int> cl(child);
}

In the copy constructor of TestClass , I first call the print() method, which works just fine. Once the shared_pointer is created, the method refers to the base class.

The output is the following:

Print from Child
Print from Base

Question: How can I create the shared pointer and not lose the dynamic dispatch functionality?

Answer 1

make_shared doesn't make an existing thing shared; it makes a new shared thing, with the type you give it.

It's effectively like this (pseudo-code only!):

template <typename T>
shared_ptr<T> make_shared(Args...)
{
    shared_ptr<T> newPtr = new T(args...);
    return newPtr;
}

In this case you're creating a Base<int> , that will be shared. It is not a child of anything. It's a sliced copy of your Child<int> .

Nothing in TestClass knows that you wanted a Child<int> , or even knows that Child<int> exists as a type.

You could do shared_ptr<Base<T>> sptr = &b to obtain a shared_ptr to an existing object. Unfortunately said object is not dynamically allocated, so that's not going to go well.

It would really be better to be consistent with your object ownership semantics. Your main function can do auto ptr = make_shared<Child<int>>() , then pass the resulting shared pointer into anything that expects a shared_ptr<Child<int>> or a shared_ptr<Base<int>> .

Without knowing what you're actually trying to do, I cannot make any more specific suggestions.