超类运算符（）错误 - 模棱两可

Question

我正在尝试使用 C++11 定义一个可以存储多个 std::function<> 的类，并根据它们的参数类型调用它们，类似于重载解析。

我为“重载”函数应该支持的每个函数签名声明一个基类：

template <typename R, typename... A>
struct overload;

template <typename R, typename... A>
struct overload<R(A...)>
{
  typedef std::function<R(A...)> F;
  F f_;
  overload(F f): f_(f) {}
  R operator()(A... a)
  {
    return f_(a...);
  }
};

template <typename... T>
struct overloaded_function : public overload<T>...
{
  overloaded_function(T... t): overload<T>(t)... {}
};

int main()
{
  overloaded_function<void(float), void(int, int)> f([](float){}, [](int, int){});
  f(1.F);  // build error
  f(2, 3); // build error
  return 0;
}

构建错误：（Visual Studio 2013）

"overload::operator() [with R=void, A=]" 不明确 c:\Users\benj7280\Documents\kernel_builder\src\main.cpp 39 5 kernel_builder

我不明白运算符怎么会模棱两可，因为函数的签名完全不同。当我完全删除模板，只使用具体的类，以及用命名成员函数替换 operator() 重载时，错误完全相同。

Answer 1

您需要将基类operator()s 包含在using 中。但是，我不知道如何使用参数包来做到这一点，所以希望其他人可以加入并回答这个问题。

我能做的是重做你的结构，让它一直线性继承，每次重载只需要using下一个：

template <typename... T>
struct overloads
{
    // need this one so that the last overload has 
    // something to "using". If you have an overload for void(),
    // that one will hide this one. If you don't, and call f(),
    // this won't compile... which is fine.
    void operator()();
};

template <typename R, typename... A, typename... T>
struct overloads<R(A...), T...>
: overloads<T...>
{
  typedef std::function<R(A...)> F;
  F f_;

  template <typename... Fs>
  overloads(F f, Fs... fs)
  : overloads<T...>(fs...)
  , f_(f)
  {}

  using overloads<T...>::operator();

  R operator()(A... a)
  {
    return f_(a...);
  }
};

template <typename... T>
struct overloaded_function : public overloads<T...>
{
  overloaded_function(T... t)
  : overloads<T...>(t...)
  { }
};

现在你的f(1.F) 和f(2, 3) 调用都编译了，因为现在所有的重载都是......可重载的。