gcc vs clang-使用`make_overload`可变参数lambda继承时不明确的重载[重复]

Question

又是一轮clang vs gcc的时间了。 Live example on godbolt.org.

---

测试0：重载的可调用对象

struct Trad
{
    auto operator()(int)    { return 1; }
    auto operator()(float)  { return 2; }
    auto operator()(double) { return 3; }
};

int main()
{
    assert(Trad{}(1) == 1);
    assert(Trad{}(1.f) == 2);
    assert(Trad{}(1.0) == 3);
}

• g++ 5.2 编译并运行。
• clang++ 3.5 （和更高版本） 编译并运行。

---

测试 1：重载的可调用对象，通过 lambda 继承生成

template <typename... TFs>
struct overload_set : TFs...
{
    overload_set(TFs... fs) : TFs(fs)... {}
};

template <typename... TFs>
auto overload(TFs&&... fs)
{
    return overload_set<TFs...>{fs...};
}

int main()
{
    auto func = overload 
    (
        [](int)    { return 1; }, 
        [](float)  { return 2; }, 
        [](double) { return 3; }
    );

    assert(func(1) == 1);
    assert(func(1.f) == 2);
    assert(func(1.0) == 3);
}

• g++ 5.2 无法编译。

  • 错误：对成员“operator()”的请求不明确

• clang++ 3.5 （和更高版本） 编译并运行。

---

这里什么编译器是正确的？

Answer 1

我可以给你一个解决方法。

template <typename... TFs>
struct overload_set : TFs...
{
  overload_set(TFs... fs) : TFs(fs)... {}
};

在这里，我们继承了一堆不同的父类型，每个父类型都有一个operator()。这些不会（至少在 gcc 中）以您想要的方式超载。

为了解决这个问题，我们线性继承并通过using 向下传递()：

template<class...Ts>
struct inherit_linearly;
template<>
struct inherit_linearly<>{};
template<class T0, class...Ts>
struct inherit_linearly<T0, Ts...>:
  T0, inherit_linearly<Ts...>
{
   using T0::operator();
   using inherit_linearly<Ts...>::operator();
   template<class A0, class...As>
   inherit_linearly( A0&&a0, As&&...as ):
     T0(std::forward<A0>(a0)),
     inherit_linearly<Ts>(std::forward<As>(as)...) 
   {}
};

现在我们替换overload_set如下：

template <typename... TFs>
struct overload_set : inherit_linearly<TFs...>
{
  using inherit_linearly<TFs...>::operator();
  overload_set(TFs... fs) :
    inherit_linearly<TFs...>(std::forward<TFs>(fs)...)
  {}
};

gcc 和 clang 都应该喜欢它。

线性继承是次优的：平衡的二叉树更好，但需要更多的工作。 （基本上，你拿一个包Xs...，然后使用小心的 TMP 将它分成Xs_front... 和Xs_back...，把它们放在一个types<...> 包中，把它们转录给你的两个父母，然后做using blah::operator() 的事情） .这是因为编译器对递归模板实例化和继承深度的限制往往比总模板实例化和继承“量”的限制更浅。

---

在c++17 中，我们不必进行这种线性继承：

template <typename... TFs>
struct overload_set : TFs...
{
  using TFs::operator()...;
  overload_set(TFs... fs) : TFs(fs)... {}
};

因为他们添加了一个新位置，您可以进行 ... 扩展。