Шаблон посетителя с использованием boost :: bind и перегруженных функций

Это должно помочь вам на полпути. Он компилируется с Visual C ++ 2010 и g ++ 4.5.1 с использованием Boost 1.46.0. Он не компилируется с реализацией Visual C ++ 2010 C ++ 0x <functional>; Я пока не знаю почему.

Настройка:

#include <iostream>
#include <iterator>
#include <string>
#include <vector>

#include <boost/bind.hpp>
#include <boost/function.hpp>

// This helper allows you to do a push_back in a bind; you can't bind
// directly to std::vector::push_back because the type of a Standard
// Library member function is unspecified.
struct do_push_back
{
    typedef void result_type;

    template <typename TSequence, typename TElement>
    void operator()(TSequence* sequence, const TElement& element) const
    {
        sequence->push_back(element);
    }
};

Демонстрация:

// Class hierarchy for demonstration:
struct B { };
struct D : B { };

// Instead of using overlodaed nonmember functions, you can overload
// operator() in a function object.  This allows you to bind to an 
// instance of this function object, not directly to one of the overloads.
struct make_string
{
    typedef std::string result_type;
    std::string operator()(const B&) const { return "B"; }
    std::string operator()(const D&) const { return "D"; }
};

int main()
{
    std::vector<std::string> strings;

    // Note that we do not use a boost::function here:
    auto f = boost::bind(do_push_back(), 
                         &strings, 
                         boost::bind(make_string(), _1));

    // Call our 'f' with B and D objects:
    f(B());
    f(D());

    std::copy(strings.begin(), strings.end(),
              std::ostream_iterator<std::string>(std::cout));
}

Результат:

BD

Вот почему это только половина решения: вы не можете сохранить результат вызова boost::bind в boost::function. Проблема в том, что когда вы используете boost::function<void(const B&)> для хранения объекта связанной функции, он всегда будет передавать const A& в качестве аргумента связанной функции.

Даже если вы вызываете объект boost::function с аргументом D, он преобразуется в const B&. При использовании boost::function теряется много информации о типе; эта потеря информации о типе необходима для того, чтобы boost::function можно было использовать в качестве универсального контейнера вызываемых объектов.

Однако это не означает, что вы не можете передавать связанный объект функции; вам просто нужно использовать шаблоны, чтобы информация о типе не терялась:

template <typename TFunction>
void test(std::vector<std::string>& strings, TFunction f)
{
    f(B());
    f(D());
}

// In main():
test(strings, f);

// Or, if you don't have C++0x's "auto", you can pass the bound 
// function object directly:
test(strings, boost::bind(do_push_back(), 
                          &strings, 
                          boost::bind(make_string(), _1)));

К сожалению, чтобы не потерять информацию о типе, необходимо передать связанный объект функции в шаблон функции. Это означает, что ваша идея сделать acceptVisitor виртуальную функцию-член не будет работать с этим решением (невозможно иметь шаблон виртуальной функции).

В любом случае, надеюсь, это будет вам полезно.

Возможно, вам будет полезен общий шаблон Visitor из библиотеки Loki.

См. http://loki-lib.sourceforge.net.

#include <iostream>
#include <Loki/Visitor.h>

struct Animal : public Loki::BaseVisitable<void, Loki::DefaultCatchAll, false>
{
};

struct Cat : public Animal
{
    LOKI_DEFINE_VISITABLE();
};

struct Dog : public Animal
{
    LOKI_DEFINE_VISITABLE();
};

struct Flower : public Loki::BaseVisitable<void, Loki::DefaultCatchAll, false>
{
};

struct Tulip : public Flower
{
    LOKI_DEFINE_VISITABLE();
};

struct AnimalAndFlowerVisitor 
    : public Loki::BaseVisitor
    , public Loki::Visitor<Cat, void, false>
    , public Loki::Visitor<Dog, void, false>
    , public Loki::Visitor<Tulip, void, false>
{
    void Visit(Dog & dog)
    {
        std::cout << "Do something with the dog\n";
    }

    void Visit(Cat & cat)
    {
        std::cout << "Do something with the cat\n";
    }

    void Visit(Tulip & tulip)
    {
        std::cout << "Do something with the tulip\n";
    }
};

int main(int argc, char* argv[])
{
    Dog dog;
    Cat cat;
    Tulip tulip;

    Animal & animalDog = dog;
    Flower & tulipFlower = tulip;

    AnimalAndFlowerVisitor visitor;
    animalDog.Accept(visitor);    // will print "Do something with the dog"
    tulipFlower.Accept(visitor);  // will print "Do something with the tulip"

    return 0;
}