有没有更好/安全的方法将 shared_ptr 的非常量引用转换为基类？

Question

如果你有一个带有虚拟方法的类 Base 和一个实现虚拟方法的类 Implementation，有没有办法将 std::shared_ptr & 转换为 std::shared &？对于 const 引用，编译器允许这样做，但对于非 const 引用，它会像下面代码中的“案例 A”一样失败。有没有简单的方法可以做到这一点？

如果不是，我在案例 B 中的解决方法“questionable_cast”的安全性如何？

#include <iostream>
#include <memory>

class Base
{
public:
    virtual void set_value(int x) = 0;
};

class Implementation : public Base
{
public:
    Implementation() : m_value(0) { }
    void set_value(int x) override
    {
    m_value = x;
    }
    int get_value() const
    {
    return m_value;
    }
private:
    int m_value;
};


void do_something(std::shared_ptr<Base>& base)
{
    base->set_value(5);

    /// Code like this makes the non-const argument necessary
    base = std::make_shared<Implementation>();
}

template <class T, class U>
std::shared_ptr<T>& questionable_cast(std::shared_ptr<U>& u)
{
    /// This code is here to assure the cast is allowed
    std::shared_ptr<T> tmp = u;
    (void)tmp;

    return *reinterpret_cast<std::shared_ptr<T>*>(&u);
}

int main()
{
    std::shared_ptr<Implementation> a = std::make_shared<Implementation>();

    // The following line causes a compiler error:
    //  invalid initialization of reference of type ‘std::shared_ptr<Base>&’ ...
    // do_something(a);
    // do_something(std::dynamic_pointer_cast<Base>(a));

    // This is the workaround
    do_something(questionable_cast<Base>(a));

    std::cerr << "a = " << a->get_value() << std::endl;

    return 0;
}

Answer 1

最初提出的问题的两个明显解决方案： 1. 使do_something 对 shared_ptr （或按值的 shared_ptr ）进行 const 引用。 2. 创建一个名为 shared_ptr 并传递对其的引用：例如

int main()
{
    std::shared_ptr<Implementation> a = std::make_shared<Implementation>();
    std::shared_ptr<Base> b = a;  // This conversion works.
    do_something(b);  // Pass a reference to b instead.
    return 0;
}

您的questionable_cast 函数违反了严格的别名规则，并调用了未定义的行为。它很可能在初始测试中起作用，然后新版本的编译器会将优化提升一个档次，但在演示期间它会失败。

处理do_something改变指针的情况：

int main()
{
    std::shared_ptr<Implementation> a = std::make_shared<Implementation>();
    std::shared_ptr<Base> b = a;  // This conversion works.
    do_something(b);  // Pass a reference to b instead.
    const auto aa = std::dynamic_pointer_cast<Implementation>(b);
    if (aa)
        a = aa;
    else
        ; // Handle the error here
    return 0;
}

如果do_something 保证返回相同派生类型的指针，即使它不返回相同的指针，也将其包装在模板函数中：

template <typename T>
void do_something_ex( std::shared_ptr<T>& a )
{
    std::shared_ptr<Base> b = a;
    do_something(b)
    a = std::dynamic_pointer_cast<T>(b);
    if (!a)
        throw_or_assert;
}