Метапрограммирование шаблона C ++ для создания boost :: варианта из shared_ptr и boost :: static_visitor

Question

В качестве личного упражнения я хочу реализовать шаблон посетителей, используя shared_ptr. Я знаком с ациклической бумагой посетителя Роберта Мартина, но нахожу навязчивую природу виртуального метода accept () и необходимое создание класса посетителя {X} для каждого класса {X} неприятным. Мне нравится класс boost :: static_visitor, поскольку он инкапсулирует всю логику локально, без необходимости {X} :: accept () и {X} Visitor.

Я ищу подсказку (как я уже сказал, я делаю это как упражнение) о том, как создать функцию шаблона rip Я упоминаю ниже. Я думаю, что это должно быть в форме:

template <typename U, typename T1, typename T2, ...>
boost::variant<T1, T2, ...> rip(U& p, boost::static_visitor<T1, T2, ...> sv)
{
    if (T1 t1 = dynamic_cast<T1>(p)) return boost::variant<T1, ...>(t1);
    ... and so on, splitting static_visitor
    return 0;  // or throw an exception
}

Буду признателен за любые подсказки или указатели на учебные пособия, делающие подобные вещи. Спасибо.

#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <boost/bind.hpp>
#include <boost/variant.hpp>


struct Base {};
struct A : Base {};
struct B : Base {};
struct C : Base {};

typedef std::shared_ptr<Base> base_ptr;
typedef boost::variant<A*,B*,C*> base_variant;
struct variant_visitor : public boost::static_visitor<void> {
    void operator()(A*, base_ptr) const {std::cout << "A*\n";}
    void operator()(B*, base_ptr) const {std::cout << "B*\n";}
    void operator()(C*, base_ptr) const {std::cout << "C*\n";}
};


int main(int, char**)
{
    // This works, of course.
    base_ptr b(new A());
    base_variant v(new A());
    boost::apply_visitor(boost::bind(variant_visitor(), _1, b), v);

    // How could we use a shared_ptr with a variant?  I almost see
    // the template magic, a function to iterate over the template
    // types from the variant_visitor and return an "any<...>".
    // base_variant rip(base_ptr&, variant_visitor) {...}
    // boost::apply_visitor(boost::bind(variant_visitor(), _1, b), rip(b, variant_visitor()));

    return EXIT_SUCCESS;
}

Answer 1

Возможно, я неправильно понимаю вопрос, но если вы хотите использовать тот же variant_visitor для варианта, содержащего общие указатели вместо простых указателей, возможно, это может быть достигнуто с другим посетителем, который получает указатель из shared_ptr и передает его другому посетителю.

#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/bind.hpp>
#include <boost/variant.hpp>


struct Base {};
struct A : Base {};
struct B : Base {};
struct C : Base {};

typedef boost::shared_ptr<Base> base_ptr;
typedef boost::variant<boost::shared_ptr<A>,boost::shared_ptr<B>,boost::shared_ptr<C> > base_variant;

template <class Visitor>
struct visit_shared_ptr_get: public boost::static_visitor<typename Visitor::result_type>
{
    //for unary visitors
    template <class FirstArg>
    typename Visitor::result_type operator()(FirstArg& first) const
    {
        return Visitor()(first.get());
    }  

    //for binary visitors, only the first argument is "ripped"
    template <class FirstArg, class SecondArg>
    typename Visitor::result_type operator()(FirstArg& first, SecondArg& second) const
    {
        return Visitor()(first.get(), second);
    }  
};

struct variant_visitor : public boost::static_visitor<void> {
    void operator()(A*, base_ptr) const {std::cout << "A*\n";}
    void operator()(B*, base_ptr) const {std::cout << "B*\n";}
    void operator()(C*, base_ptr) const {std::cout << "C*\n";}
};


int main(int, char**)
{
    // This works, of course.
    base_ptr b(new A());
    base_variant v(boost::shared_ptr<A>(new A()));
    boost::apply_visitor(boost::bind(visit_shared_ptr_get<variant_visitor>(), _1, b), v);
    return EXIT_SUCCESS;
}

---

Редактировать: downcaster, который вы, кажется, представляете.

#include <stdexcept>
#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/variant.hpp>
#include <boost/variant/variant_fwd.hpp>
#include <boost/preprocessor/repetition.hpp>

//dynamic_cast will only compile if the target type is a pointer
template <class Derived, class Base, class Variant>
typename boost::enable_if<boost::is_pointer<Derived>, bool>::type cast_if_pointer( Base* b, Variant& variant)
{
    if (Derived p = dynamic_cast<Derived>(b)) { variant = p; return true; }
    return false;
}

//weeds out boost's unused template parameters and other non-pointers
template <class Derived, class Base, class Variant>
typename boost::disable_if<boost::is_pointer<Derived>, bool>::type cast_if_pointer( Base*, Variant& )
{
    return false;
}

template <class P, BOOST_VARIANT_ENUM_PARAMS(class T)>
void rip(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& variant, const boost::shared_ptr<P>& smart_ptr)
{
#define ATTEMPT_CAST(z, n, type) if (cast_if_pointer<T ## n >(smart_ptr.get(), variant)) return;
    BOOST_PP_REPEAT(BOOST_VARIANT_LIMIT_TYPES, ATTEMPT_CAST, T)
#undef ATTEMPT_CAST
    throw std::bad_cast();
}

struct Base 
{
    virtual ~Base() {}
};

struct A : Base {};
struct B : Base {};
struct C : Base {};


typedef boost::shared_ptr<Base> base_ptr;
typedef boost::variant<A*,B*,C*> base_variant;


int main(int, char**)
{
    base_ptr b(new A());
    base_variant v;
    rip(v, b);

    return EXIT_SUCCESS;
}

Answer 2

Вы не можете использовать посетителя для вывода типа, потому что у него есть только один аргумент шаблона - для result_type. Его operator() может вызываться или не вызываться для всех типов, которые может хранить произвольный boost::variant.

Я только предполагаю, что вам может понадобиться следующее (мое первое использование библиотеки препроцессора boost):

#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <boost/bind.hpp>
#include <boost/variant.hpp>

#include <boost/variant/variant_fwd.hpp>
#include <boost/preprocessor/repetition.hpp>

#define SHARED_PTR_TO_PTR(z, n, text) BOOST_PP_COMMA_IF(n) typename shared_ptr_to_ptr<text ## n>::type

template <class T>
struct shared_ptr_to_ptr { typedef T type; };

template <class T>
struct shared_ptr_to_ptr<std::shared_ptr<T> > {typedef T* type; };

template <class T>
struct unsmartify_variant;


template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
struct unsmartify_variant<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T) > >
{
    typedef boost::variant<BOOST_PP_REPEAT(BOOST_VARIANT_LIMIT_TYPES, SHARED_PTR_TO_PTR, T)> type;
};

template <class Variant>
struct get_visitor: boost::static_visitor<typename unsmartify_variant<Variant>::type >
{
    template <class SharedPtr>
    typename unsmartify_variant<Variant>::type operator()(SharedPtr& p) const
    {
        return p.get();
    }
};

template <class Variant>
typename unsmartify_variant<Variant>::type rip(Variant& variant)
{
    return boost::apply_visitor(get_visitor<Variant>(), variant);
}

struct Base {};
struct A : Base {};
struct B : Base {};
struct C : Base {};

typedef std::shared_ptr<Base> base_ptr;
typedef boost::variant<std::shared_ptr<A>,std::shared_ptr<B>,std::shared_ptr<C> > base_variant;

struct variant_visitor : public boost::static_visitor<void> {
    void operator()(A*, base_ptr) const {std::cout << "A*\n";}
    void operator()(B*, base_ptr) const {std::cout << "B*\n";}
    void operator()(C*, base_ptr) const {std::cout << "C*\n";}
};

int main(int, char**)
{
    // This works, of course.
    base_ptr b(new A());
    base_variant v(std::shared_ptr<A>(new A()));
    unsmartify_variant<base_variant>::type k = rip(v);
    boost::apply_visitor(boost::bind(variant_visitor(), _1, b), k);
    return EXIT_SUCCESS;
}

Самая большая проблема в том, что boost::variant принимает фиксированное количество аргументов.

Также представляется, что variant передается в apply_visitor по неконстантной ссылке, то есть результат rip должен храниться в именованной переменной.