Использование объявления в вариационном шаблоне

Этот вопрос вдохновлен следующим решением на многократную перегрузку наследования с псевдо-двусмысленностью, что является хорошим способом внедрения лямбда-посетителей для boost:: variant, как предлагается в этот ответ:

Я не уверен, что будет правильным синтаксисом добавления разделов для списков упакованных типов. Предложение using имеет решающее значение, чтобы остановить компилятор от жалобы на то, что operator() неоднозначны, а это совсем не так, потому что у них есть все разные подписи.

Ответы

Ответ 1

Хорошо, я нашел довольно приличное решение:

В основном мне нужно распаковать один лишний лямбда-регистр и применить предложение using к распакованной лямбда, а остальное, но в этом случае, поскольку я, по-видимому, не могу сделать вариационный список использования объявлений (по крайней мере, t знать синтаксис, если это возможно), остальное обернуто путем наследования из "остального" случая, например:

template <typename ReturnType, typename... Lambdas>
struct lambda_visitor;

template <typename ReturnType, typename Lambda1, typename... Lambdas>
struct lambda_visitor< ReturnType, Lambda1 , Lambdas...> 
  : public lambda_visitor<ReturnType, Lambdas...>, public Lambda1 {

    using Lambda1::operator();
    using lambda_visitor< ReturnType , Lambdas...>::operator();
    lambda_visitor(Lambda1 l1, Lambdas... lambdas) 
      : Lambda1(l1), lambda_visitor< ReturnType , Lambdas...> (lambdas...)
    {}
};


template <typename ReturnType, typename Lambda1>
struct lambda_visitor<ReturnType, Lambda1> 
  : public boost::static_visitor<ReturnType>, public Lambda1 {

    using Lambda1::operator();
    lambda_visitor(Lambda1 l1) 
      : boost::static_visitor<ReturnType>(), Lambda1(l1)
    {}
};


template <typename ReturnType>
struct lambda_visitor<ReturnType> 
  : public boost::static_visitor<ReturnType> {

    lambda_visitor() : boost::static_visitor<ReturnType>() {}
};

Поэтому я могу сделать это индуктивно, разместив два объявления с использованием объявлений, одно из нераспакованного лямбда-типа и другое из родительского класса, которое на самом деле является одним и тем же классом с одним меньшим количеством лямбда.

Ответ 2

Это старый вопрос и отличный ответ. Там еще одна вещь, которую мы можем сделать, чтобы улучшить ее ИМХО.

В С++ 14 и выше нам не нужно указывать тип возврата - его можно вывести.

#include <boost/variant.hpp>
#include <type_traits>

namespace detail {

    template<typename... Lambdas>
    struct lambda_visitor;

    template<typename Lambda1, typename... Lambdas>
    struct lambda_visitor<Lambda1, Lambdas...>
        : public lambda_visitor<Lambdas...>,
          public Lambda1
    {

        using Lambda1::operator ();
        using lambda_visitor<Lambdas...>::operator ();

        lambda_visitor(Lambda1 l1, Lambdas... lambdas)
            : Lambda1(l1)
            , lambda_visitor<Lambdas...>(lambdas...) {}
    };

    template<typename Lambda1>
    struct lambda_visitor<Lambda1>
        :
            public Lambda1
    {

        using Lambda1::operator ();

        lambda_visitor(Lambda1 l1)
            : Lambda1(l1) {}
    };
}

template<class...Fs>
auto compose(Fs&& ...fs)
{
    using visitor_type = detail::lambda_visitor<std::decay_t<Fs>...>;
    return visitor_type(std::forward<Fs>(fs)...);
};

прецедент:

boost::variant<int, std::string> x = "foo", y = 4;

auto visitor = compose([](const int& i)
                       {
                           std::cout << i << std::endl;
                       },
                       [](const std::string& s)
                       {
                           std::cout << s << std::endl;
                       });

boost::apply_visitor(visitor, x);
boost::apply_visitor(visitor, y);