Question

我确信这是一个坏主意。让我们假装我有充分的理由去做。我有一个节点树，成功使用静态多态传递消息。至关重要的是，每个节点都不能连接它所连接的节点的类型，它只知道它传递的消息类型。为了遍历树，我使用CRTP实现了访问者模式。这适用于树的第一级。

但是，当遍历到树的第二层时，使用下面的AnyNode类擦除下一个节点的类型。我一直无法弄清楚如何从擦除类型转变为混凝土类型。下面的例子在测试中起作用，但我认为它也可能非常危险，并且只是通过运气来计算内存。

我必须删除AnyNode::Model<T>::acceptDispatch中访问者的类型，这在AnyNode::Concept::accept中完全已知，这似乎有问题。但我无法弄清楚如何从概念向模型 in 概念（我尝试了一个协变虚拟cast函数，但这没有用）。并且我无法使用虚方法将类型化的访问者传递给派生的Model类，因为虚拟方法无法模板化。

是否有一种安全的方式来调用node.accept并传递访问者而不必删除访问者的类型然后静态回放？有没有办法在运行时将Concept转发为Model<T>？有没有更好的方法来解决这个问题？是不是有一些疯狂的新C ++ 11解决方法，可能与SFINAE？

class AnyNode
{
    struct Concept
    {
        virtual ~Concept() = default;

        template< typename V >
        void accept( V & visitor )
        {
            acceptDispatch( &visitor );
        }

        virtual void acceptDispatch( VisitorBase * ) = 0;
    };

    template< typename T >
    struct Model : public Concept
    {
        Model( T &n ) : node( n ) {}

        void acceptDispatch( VisitorBase * v ) override
        {
            // dynamic cast doesn't work, probably for good reason
            NodeVisitor< T >* visitor = static_cast< NodeVisitor< T >* >( v );
            std::cout << "CAST" << std::endl;
            if ( visitor ) {
                std::cout << "WAHOO" << std::endl;
                node.accept( *visitor );
            }
        }

    private:
        T &node;
    };

    std::unique_ptr< Concept > mConcept;
public:

    template< typename T >
    AnyNode( T &node ) :
            mConcept( new Model< T >( node )) {}


    template< typename V >
    void accept( V & visitor )
    {
        mConcept->accept( visitor );
    }
};

编辑这里是访客基类，以及一个示例派生访客。派生的访问者由客户端代码实现（这是库的一部分），因此基类无法知道将实现哪些访问者。我担心这会分散中心问题，但希望它能帮助解释一下这个问题。除非在->accept( visitor )中的AnyNode指针上调用outlet_visitor::operator()，否则此处的所有内容都有效。

// Base class for anything that implements accept
class Visitable
{
public:
};


// Base class for anything that implements visit
class VisitorBase
{
public:
    virtual ~VisitorBase() = default;
};

// Visitor template class

template< typename... T >
class Visitor;

template< typename T >
class Visitor< T > : public VisitorBase
{
public:
    virtual void visit( T & ) = 0;
};

template< typename T, typename... Ts >
class Visitor< T, Ts... > : public Visitor< Ts... >
{
public:
    using Visitor< Ts... >::visit;

    virtual void visit( T & ) = 0;
};

template< class ... T >
class NodeVisitor : public Visitor< T... >
{
public:

};

// Implementation of Visitable for nodes

template< class V >
class VisitableNode : public Visitable
{
    template< typename T >
    struct outlet_visitor
    {
        T &visitor;
        outlet_visitor( T &v ) : visitor( v ) {}


        template< typename To >
        void operator()( Outlet< To > &outlet )
        {
            for ( auto &inlet : outlet.connections()) {
                auto n = inlet.get().node();
                if ( n != nullptr ) {
                    // this is where the AnyNode is called, and where the
                    // main problem is
                    n->accept( visitor );
                }
            }
        }
    };

public:
    VisitableNode()
    {
        auto &_this = static_cast< V & >( *this );
        _this.each_in( [&]( auto &i ) {
            // This is where the AnyNode is stored on the inlet,
            // so it can be retrieved by the `outlet_visitor`
            i.setNode( *this );
        } );
    }

    template< typename T >
    void accept( T &visitor )
    {
        auto &_this = static_cast< V & >( *this );
        std::cout << "VISITING " << _this.getLabel() << std::endl;

        visitor.visit( _this );

        // The outlets are a tuple, so we use a templated visitor which
        // each_out calls on each member of the tuple using compile-time
        // recursion.
        outlet_visitor< T > ov( visitor );
        _this.each_out( ov );
    }
};

// Example instantiation of `NodeVistor< T... >`

class V : public NodeVisitor< Int_IONode, IntString_IONode > {
public:

    void visit( Int_IONode &n ) {
        cout << "Int_IONode " << n.getLabel() << endl;
        visited.push_back( n.getLabel());
    }

    void visit( IntString_IONode &n ) {
        cout << "IntString_IONode " << n.getLabel() << endl;
        visited.push_back( n.getLabel());
    }

    std::vector< std::string > visited;
};

Answer 1

啊，我想我现在看到了你的问题。此处dynamic_cast（以及static_cast）的问题是，具有多种类型的NodeVisitor不会生成所有单一类型的Visitor类。

在您提供的示例中，课程V来自NodeVisitor< Int_IONode, IntString_IONode >，最终会生成Visitor< Int_IONode, IntString_IONode >和Visitor< IntString_IONode >个类作为基础。请注意，未生成Visitor< Int_IONode >。（visit<Int_IONode>位于Visitor< Int_IONode, IntString_IONode >。）您也没有NodeVisitor< Int_IONode >或NodeVisitor< IntString_IONode >。将任何内容转换为任何一个类都将是Undefined Behavior，因为您要从中投射的类不能是其中之一。

要解决这个问题，您需要生成所有单一类型Visitor类。我觉得这样的事情可能有用（注意：未经测试）：

template< typename T, typename... Ts >
class Visitor< T, Ts... > : public Visitor< T >, public Visitor< Ts... >
{
public:
    using Visitor< T >::visit;
    using Visitor< Ts... >::visit;
};

这将定义单个类型visit类中的所有Visitor方法。

接下来，将visitor中的acceptDispatch更改为

auto visitor = dynamic_cast< Visitor< T >* >( v );

由于v是VisitorBase，如果所有内容都已正确声明，则应该会转到所需的Visitor类和包含的visit方法。

Answer 2

不，这是不可能的。

假设您有3个模块。第1单元是您的库。模块2定义节点类型。第3单元定义了一个访问者。

它们被单独编译为二进制动态库，然后在运行时加载。

如果访问者知道节点类型的完整类型，它将能够对节点类型的属性进行任意编译时检查，确实改变它的行为方式。例如，它在编译时检查静态node_type::value是否编码“P = NP”的证明。

同时，节点类型DLL中的任何人都不使用node_type::value，因此编译器会对其存在进行优化（非常有效）。

要做你要求的事情，你不仅要发送node_type的编译结果，还要发送等同于node_type的整个源的内容。 visitor DLL，在该DLL中，他们可以针对此特定visitor重新编译node_type。

如果你放宽了十几个隐含要求中的任何一个，这是可行的，但你已经选择了一组不相容的要求。很可能你要求的不是你真正需要的东西，你只是想提出极其普遍的要求，并指出它已经足够了，然后为什么你不能这样做而感到困惑。

混合双调度和静态多态

2 个答案: