22

C ++テンプレートを使用してビジターパターンを実装することにより、コード内のボイラープレートの量を削減しようとしています。これまでのところ、私はこれを思いついた：

class BaseVisitor {
public:
    virtual ~BaseVisitor() {}
};

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

template<typename Derived>
class Visitable {
public:
    void accept(Visitor<Derived>& visitor) {
        visitor.visit(static_cast<Derived&>(*this));
    }
};

そして、Visitableの各サブクラスは次のようになります。

class Mesh : public Object, public Visitable<Mesh> {};
class Text : public Object, public Visitable<Text> {};

そして最後に、訪問者は次のようになります。

class Renderer : public Visitor<Mesh>, public Visitor<Text> {}

これまでのところ良い...今ここに問題があります：

for(Scene::iterator it = scene.begin(); it != scene.end(); ++it) {
    Object& object = static_cast<Object&>(*it);
    if(pre_visit(object)) {
        object.accept(this); ///Erm, what do I cast to??
        post_visit(object);
    }
}

accept（）を呼び出すことができるように、どういうわけかVisitableにキャストする必要がありますが、明らかにTが何であるかわかりません。または、Visitableテンプレートに仮想accept（）を追加することはできません。これは、どの引数を取るべきかわからないためです。

C ++テンプレートの第一人者は、これを機能させる方法を知っていますか？

4

3 に答える 3

25

これは、可変個引数テンプレートを使用してC++11で実行できます。ピートの答えから続く：

// Visitor template declaration
template<typename... Types>
class Visitor;

// specialization for single type    
template<typename T>
class Visitor<T> {
public:
    virtual void visit(T & visitable) = 0;
};

// specialization for multiple types
template<typename T, typename... Types>
class Visitor<T, Types...> : public Visitor<Types...> {
public:
    // promote the function(s) from the base class
    using Visitor<Types...>::visit;

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

template<typename... Types>
class Visitable {
public:
    virtual void accept(Visitor<Types...>& visitor) = 0;
};

template<typename Derived, typename... Types>
class VisitableImpl : public Visitable<Types...> {
public:
    virtual void accept(Visitor<Types...>& visitor) {
        visitor.visit(static_cast<Derived&>(*this));
    }
};

のサブクラスVisitable：

class Mesh : public Object, public VisitableImpl<Mesh, Mesh, Text> {};
class Text : public Object, public VisitableImpl<Text, Mesh, Text> {};

Visitorサブクラス：

class Renderer : public Visitor<Mesh, Text> {};

コンテナが何であるかは明確ではありませんがvalue_type、呼び出すScene参照またはポインタを取得する必要があります。Visitable<Mesh, Text>accept

for(Scene::iterator it = scene.begin(); it != scene.end(); ++it) {
    Visitable<Mesh, Text>& object = static_cast<Visitable<Mesh, Text>&>(*it);
    if(pre_visit(object)) {
        object.accept(*this);
        post_visit(object);
    }
}
于 2012-08-03T19:27:34.337 に答える
6

BaseVisitorは、任意の訪問者が訪問者を削除できるようにする以外は何もしません。代わりに、ビジターに対して呼び出すことができるさまざまな機能のすべてを提供するビジター用の基本クラスと、このビジターを受け入れるための基本クラスが必要です。acceptVisitable

これを行うには、タイプリストを使用して、訪問者が受け入れることができるタイプを定義し、タイプリストを取得する基本訪問者クラスを作成し、訪問者の実装にパラメーターとしてタイプリストを追加します。

例のスケッチ：

// assuming a typelist has typedefs first and second and a 
// type 'empty' representing end of type list

template<typename Types>
class Visitor : public Visitor<Types::second> {
public:
    // visitor has a visit function for each type in Types
    virtual void visit(typename Types::first& visitable) = 0;
};

template<> class Visitor<empty> { };

template<typename Types>
class Visitable{
    public:
    // base accepts a visitor which can visit any type in Types
    virtual void accept(Visitor<Types>& visitor) = 0;
};

template<typename Derived, typename Types>
class VisitableImpl : public Visitable<Types> {
public:
    // impl calls specific visit function 
    virtual void accept(Visitor<Types>& visitor) override {
        visitor.visit(static_cast<Derived&>(*this));
    }
};
于 2012-08-03T13:43:30.827 に答える
0

また、テンプレート化されたビジターパターンが必要であり、可変個引数タイプやタイプリストの使用を伴わないソリューションを作成することができました。

// forward declarations for our Visitable interface
class Object;
class Visitor;

// Visitable objects can accept a visitor.
class Visitable
{
public:
    virtual ~Visitable() { }
    virtual void accept_visitor(Visitor& visitor) = 0;
    virtual void accept(Object& obj);
};

// A base class, to allow downcasting
class Object
{
protected:
    virtual void _f() { }
};

// Our Visitor class, which will wrap our concrete visitor implementation
class Visitor
{
public:
    Visitor(Object* obj);

    // Base class for concrete visitors
    template<typename D, typename V>
    class OfType : public Object
    {
    public:
        void visit(V* visitable) {
            D* derived = static_cast<D*>(this);

            // "duck-typed" method; if our derived class does not have
            // this method, compilation will fail.
            derived->on_visit(visitable);
        }
    };

    template<typename D, typename V>
    void visit(V* visitable);

private:
    Object* m_obj;
};

Visitor::Visitor(Object* obj) : m_obj(obj) { }

template<typename D, typename V>
void Visitor::visit(V* visitable) {
    // check if our visitor is able to visit this instance
    OfType<D,V>* visitor = dynamic_cast<OfType<D,V>* >(m_obj);
    if (visitor) {
        visitor->visit(visitable);
    }
}

void Visitable::accept(Object& visitor) {
    Visitor wrapped(&visitor);
    accept_visitor(wrapped);
}

上記のインターフェイスを定義したら、訪問可能なオブジェクトの訪問者用に特定のインターフェイスを作成し、それらを具象クラスに実装します。

class This;

class ThisVisitor : public Visitor::OfType<ThisVisitor, This>
{
public:
    virtual void on_visit(This* item) = 0;
};

class This : public Visitable
{
public:
    void accept_visitor(Visitor& visitor) {
        visitor.visit<ThisVisitor>(this);
    }
};

class That;

class ThatVisitor : public Visitor::OfType<ThatVisitor, That>
{
public:
    virtual void on_visit(That* item) = 0;
};

class That : public Visitable
{
public:
    void accept_visitor(Visitor& visitor) {
        visitor.visit<ThatVisitor>(this);
    }
};

class MyVisitor : public ThisVisitor, public ThatVisitor
{
public:
    void on_visit(This* item) { printf("This!"); }
    void on_visit(That* item) { printf("That!"); }
};

int main(int argc, const char* argv[] {
    This item1;
    That item2;
    MyVisitor visitor;
    item1.accept(visitor);   // "This!"
    item2.accept(visitor);   // "That!"
}

ビジターインターフェイスを完全にスキップして、具体的なビジターを直接派生させることもできますがOfType<Derived, SomeClass>、新しいクラスが定義されているため、ビジターを拡張するには前者を使用する方が良いと思います（Thatタイプである限り、誰がビジターを訪問するかは気にしないでくださいThatVisitor） 。 。

于 2019-02-12T21:39:11.410 に答える