c++ - 在带有虚拟析构函数的多态继承中使用 enable_shared_from_this

Question

我有以下类结构用于管理具有不同原型(prototype)的回调:

class MethodHandlerBase: public std::enable_shared_from_this<MethodHandlerBase>{
public:
    virtual void operator()(void* data) = 0;
    virtual ~MethodHandlerBase(){}
};
   
class MethodHandlerA: public MethodHandlerBase{
private:
    MethodHandlerACallback cb;
public:
    MethodHandlerA(MethodHandlerACallback cb): cb(cb){}
    virtual void operator()(void* data);
};
    
class MethodHandlerB: public MethodHandlerBase{
private:
    MethodHandlerBCallback cb;
public:
    MethodHandlerB(MethodHandlerBCallback cb): cb(cb){}
    virtual void operator()(void* data);
};

在某些情况下 MethodHandlerA或 MethodHandlerB可能使用 this (包装在 shared_ptr 中)在传递给其他地方的 lambda 表达式中，所以我需要确保它在需要时被正确删除。因此我添加了 std::enable_shared_from_this<MethodHandlerBase>继承到基类。
但我读到你通常不能使用 std::enable_shared_from_this通过继承(除了使用模板，它实际上不再是继承)。据我了解，这是由于可能错误地破坏了实例。在这种情况下，我会假设我的代码可以正常工作，因为它使用了虚拟析构函数(无论如何都需要)。
我的理论是对的还是关于 std::enable_shared_from_this 的其他事情发生了？我不明白的继承？
编辑 :
添加一个我打算使用它的简短示例:
从类内部:

void MethodHandlerB::operator()(void* data){
    std::shared_ptr<MethodHandlerB> thisPtr = std::dynamic_pointer_cast<MethodHandlerB>(this->shared_from_this());
    putLamdaToSomeGlobalEventThing([thisPtr](){
        thisPtr->doSomething();
    });
}

并且从外面

std::vector<MethodHandlerBase> vec{std::make_shared<MethodHandlerB>()};

Answer 1

一些小点:

您可以将共享指针移动到 lambda 中以避免原子递增和递减

无需使用动态指针强制转换，因为您肯定知道动态类型(而且您不检查结果是否为空!)

void MethodHandlerB::operator()(void* data){
    auto thisPtr = std::static_pointer_cast<MethodHandlerB>(this->shared_from_this());
    putLamdaToSomeGlobalEventThing([thisPtr = std::move(thisPtr)](){
        thisPtr->doSomething();
    });
}

或者，您可以对 this 使用单独的捕获。和共享指针，它完全避免了强制转换:

void MethodHandlerB::operator()(void* data){
    putLamdaToSomeGlobalEventThing([this, thisPtr = shared_from_this()](){
        doSomething();
    });
}

编辑:正如其中一条评论指出的那样，如果您不使用 shared_from_this()直接在基类上，最好从 enable_shared_from_this 派生在派生类中。您可以这样做，因为 C++ 支持多重继承。

class MethodHandlerBase {
public:
    virtual void operator()(void* data) = 0;
    virtual ~MethodHandlerBase(){}
};
   
class MethodHandlerA: 
    public MethodHandlerBase,
    public std::enable_shared_from_this<MethodHandlerA>
{
private:
    MethodHandlerACallback cb;
public:
    MethodHandlerA(MethodHandlerACallback cb): cb(cb){}
    virtual void operator()(void* data);
};

void MethodHandlerA::operator()(void* data){
    putLamdaToSomeGlobalEventThing([self = shared_from_this()](){
        self->doSomething();
    });
}