在可变参数模板中使用声明答案

【问题标题】：using declaration in variadic template在可变参数模板中使用声明
【发布时间】：2011-12-13 19:19:08
【问题描述】：

这个问题的灵感来自于 following solution 中的多重继承重载伪歧义，这是实现 this answer 中提出的 boost::variant 的 lambda 访问者的好方法：

我想做如下的事情：

template <typename ReturnType, typename... Lambdas>
struct lambda_visitor : public boost::static_visitor<ReturnType>, public Lambdas... {
    using Lambdas...::operator(); //<--- doesn't seem to work
    lambda_visitor(Lambdas... lambdas) : boost::static_visitor<ReturnType>() , Lambdas(lambdas)... { }
};

我不确定为压缩类型列表添加 using 子句的正确语法是什么。 using 子句对于阻止编译器抱怨 operator() 模棱两可至关重要，而这完全不是，因为它们具有所有不同的签名。

【问题讨论】：

有一个P0195R2“使用声明中的包扩展”提案。
using 声明上下文中的参数包扩展符合 C++17 标准。

标签： c++ operator-overloading c++11 multiple-inheritance variadic-templates

【解决方案1】：

好的，我找到了一个相当不错的解决方案：

基本上我需要解压缩一个额外的 lambda 案例并将 using 子句应用于解压缩的 lambda 和其余部分，但在这种情况下，因为我显然无法制作使用声明的可变参数列表（至少我没有不知道语法，如果可能的话），其余部分通过从“rest”案例继承来包装，如下所示：

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>() {}
};

所以我可以通过放置两个 using 声明来归纳地做到这一点，一个来自未打包的 lambda 类型，另一个来自父类，它实际上是同一个类，但少了一个 lambda。

【讨论】：

啊，我在我的回答中看到了你的 cmets，现在正要发布这个解决方案 :) 可惜优雅的解决方案有点毛茸茸 :(
@RMartinho，不是真的，仍然是很好的解决方案，谢谢
也谢谢你！我学到了另一个奇怪的 C++ 极端案例！ :)
请注意，由于您有一个using 声明将operator() 带入范围，您现在可以从函子类型私下继承。闭包并不那么有趣，因为 lambda 表达式的类型是独一无二的，但您的解决方案实际上适用于任何提供 operator() 的东西，因此更多的封装不会受到伤害。只需做一些工作，您也可以处理函数的指针/引用:)
派生列表中的元素顺序与构造函数初始化中不同。在使用 Wall 标志的编译器（g++ 4.7.2）上，我收到警告说派生类型将以错误的顺序初始化（-Wreorder）。更正顺序后，工作正常:)

【解决方案2】：

这是一个老问题，也是一个很好的答案。恕我直言，我们还可以做一件事来改进它。

在 c++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);

【讨论】：