仅推导可变参数模板的参数类型

Question

我正在尝试将可变参数模板函数应用于元组。我发现以下适用于 C++14 的解决方案（请参阅https://stackoverflow.com/a/37100646/2712726）。

#include <tuple>
template <typename T, typename U> void my_func(T &&t, U &&u) {}
int main(int argc, char *argv[argc]) {
  std::tuple<int, float> my_tuple;
  std::apply([](auto &&... args) { my_func(args...); }, my_tuple);
  return 0;
}

我还找到了许多针对 C++11 的解决方案，但没有一个已编译。所以我实现了自己的解决方案，但也无法编译。

以下代码显示了我的尝试。我的问题是为什么最后一个语句

u.apply(f)

中的类型推导失败以及我是否可以以某种方式帮助编译器。

#include <iostream>
#include <tuple>

using namespace std;

template <typename... T>
struct parameter_pack : public parameter_pack<T>... {
    parameter_pack(const T&... t) : parameter_pack<T>(t)... {}

    // C++11
    template <template <typename...> class Func>
    void apply(Func<T...> f) {
        f(parameter_pack<T>::h...);
    }
    //c++14 works
    // template <typename Func>
    // void apply(Func f) {
    //     f(parameter_pack<T>::h...);
    // }
};

template <typename H>
struct parameter_pack<H> {
    parameter_pack(const H& h) : h(h) {}
    const H& h;
};

template <typename... T>
parameter_pack<T...> make_parameter_pack(const T&... t) {
    return parameter_pack<T...>(t...);
}

// test function f()
template <typename H>
void f(const H& h) {
    std::cout << h << std::endl;
}

template <typename H, typename... T>
void f(const H& h, const T&... t) {
    f(h);
    f(t...);
}

int main() {
    auto u = make_parameter_pack(1, 1.1, "hello");
    std::cout << std::endl;
    // C++11
    u.apply(f); // compiler error

    //C++14 works
    // auto lambda = [&](const auto&... args) {
    //    f(args...);
    // };
    // u.apply(lambda);
}

编译器说：

<source>:49:7: error: no matching member function for call to 'apply'
   49 |     u.apply(f);
      |     ~~^~~~~
<source>:12:10: note: candidate template ignored: couldn't infer template argument 'Func'
   12 |     void apply(Func<T...> f) {
      |          ^
1 error generated.
Compiler returned: 1

Answer 1

f

是一个模板函数，你不能获取“函数蓝图”的地址。您可以获取

f<int>

的地址，但不能获取

f

的地址。

为什么它可以与 lambda 一起使用？因为 lambda 只是可调用结构的语法糖：您将传递一个存在并驻留在内存中某处的对象，因此调用运算符是模板化的事实没有任何影响。如果您通过

lambda::operator()

或任何其他变体，您会回到与上面相同的问题。