c++ - 多态树类中的双指针向上转换(再次)、shared_ptr 和通用 setChild 函数

Question

我有一个摘要Node类，派生于许多子类，例如Color , Texture , Shape , Light等...包含我的应用程序用户数据。数据包含在这些节点的大树中。每个Node子类有固定数量的子类，它们是固定类型的。例如，一种 Material 可以有一个颜色子项和一个纹理子项。这些存储为 std::shared_ptr的

目前，每个类派生一个setChild方法，它需要一个 Node作为论据。每个实现都使用 dynamic_cast 检查类型及其子类型。相应地，如果成功则设置它。

我想实现一个通用的 setChild Node 中的方法，而不需要对其进行子类化。为此，每个子类都将在构造函数中声明(或注册)其子类，方法是提供一个名称字符串、一个类型字符串(对应于子类)和一个指向 shared_ptr 的指针。到 Node .

你现在可以看到问题了:

• 我将使用 **SubClass , 向上转换为 **Node ，我知道这很糟糕，但由于每个子类都有一个 type()方法来唯一标识类，并且由于我知道每个已注册子类的类型，因此我可以仔细检查以避免使用双指针存储错误的指针类型。
• 实际上我不会用 **Node 来做这件事, 但带有 *std::shared_ptr<Node> .在这里，我不确定是否做对了。

问题:

• 是否可以设置 shared_ptr<Subclass>用*shared_ptr<Node>即使我确定类型？
• 这是按照您的方式设计的吗？

谢谢，

艾蒂安

Answer 1

如果我理解你，以下是不安全的:

boost::shared_ptr<SpecificNode> realPtr;
boost::shared_ptr<Node>* castPtr;

// castPtr = &realPtr; -- invalid, cannot cast from one to the other
castPtr = reinterpret_cast<boost::shared_ptr<Node>*>(&castPtr);
castPtr->reset(anything); // illegal.  castPtr does not point
                          // to a boost::shared_ptr<Node*>

现在你可能会很幸运，内存可能会排队，但这不是有效的 C++。

如果您正在寻找扩展第 3 方插件中的节点集，唯一的解决方案是一系列动态转换，所以让我们看看我们可以做些什么来使注册工作。

与其尝试使用强制转换来完成所有操作，不如考虑使用模板来执行类型安全操作。有一个接受节点共享指针的抽象基类，并且要么使用它，要么不使用它

(从现在开始，我将使用 T::Ptr 而不是 boost::shared_ptr，假设有 typedef。这只是为了便于 stackoverflow 阅读)

class Registration
{
    public:
        typedef boost::shared_ptr<Registration> Ptr;

        virtual bool    consume(const Node::Ptr&) = 0;
};

template <typename T>
class SpecificRegistration : public Registration
{
    public:
        SpecificRegistration(T::Ptr& inChildPtr)
        : mChildPtr(inChildPtr)
        { }

        virtual bool    consume(const Node:Ptr& inNewValue)
        {
            if(!inNewValue) {
                mChildPtr.reset();
                return true; // consumed null ptr
            } else {
                T::Ptr newValue = dynamic_pointer_cast<T>(inNewValue);
                if (newValue) {
                    mChildPtr = newValue;
                    return true; // consumed new value
                } else {
                    return false; // no match
                }
            }
        }
    private:
        T::Ptr&    mChildPtr;
};

template <typename T>
Registration::Ptr registerChild(T::Ptr& inChildPtr)
{
    return make_shared<SpecificRegistration<T> >(inChildPtr);
}

// you can also register vector<T::Ptr> if you write an
// ArraySpecificRegistration class which uses push_back when
// it consumes a node

void Node::setNode(const Node& inNode) {
    for (RegistrationList::iterator iter = mRegistration.begin(); iter != mRegistration.end(); ++iter) {
        if (mRegistration->consume(inNode))
            return;
    }
    throw runtime_error("Failed to set any children of the node");
}

class SomeThirdPartyNode
: public Node
{
    public:
        SomeThirdPartyNode()
        {
            // all they have to write is one line, and mOtherTHing is
            // registered
            addChild(registerChild(mOtherThing));
        }
    private:
        SomeOtherThirdPartyNode::Ptr  mOtherThing;
};