Question

考虑这个有效的代码：

#include <iostream>
#include <utility>
#include <array>

template <typename... Args>
void foo (Args&&... args) {
    const auto v = {args...};
    for (auto x : v) std::cout << x << ' ';     std::cout << '\n';
}

template <typename> struct Foo;

template <std::size_t... Is>
struct Foo<std::index_sequence<Is...>> {
    template <typename Container>
    static void execute (const Container& v) {
        foo(v[Is]...);
    }
};

template <std::size_t N>
void fooArray (const std::array<int, N>& a) {
    Foo<std::make_index_sequence<N>>::execute(a);
}

int main() {
    fooArray<6>({0,1,2,3,4,5});  // 0 1 2 3 4 5
}

我想现在概括Foo结构如下：

#include <iostream>
#include <utility>
#include <array>

template <typename... Args>
void foo (Args&&... args) {
    const auto v = {args...};
    for (auto x : v) std::cout << x << ' ';     std::cout << '\n';
}

template <typename> struct Foo;

template <std::size_t... Is>
struct Foo<std::index_sequence<Is...>> {
    template <typename Container, typename F>  // *** Modified
    static void execute (const Container& v, F f) {
        f(v[Is]...);
    }
};

template <std::size_t N>
void fooArray (const std::array<int, N>& a) {
    Foo<std::make_index_sequence<N>>::execute(a, foo);
}

int main() {
    fooArray<6>({0,1,2,3,4,5});
}

但是我得到一个编译错误（来自GCC 4.9.2），不能推断出F.我如何实现这一目标？

Answer 1

foo是一系列重载，因此foo含糊不清（甚至foo<int, int>也是，因为它也可能有其他类型。）

您可以强制执行预期的类型函数，如下所示：

template <std::size_t... Is>
struct Foo<std::index_sequence<Is...>> {
    template <typename Container>
    static void execute (const Container& v, void (*f)(decltype(v[Is])&...)) {
        f(v[Is]...);
    }
};

Live example

另一种方法是将函数foo包装到类中：

class FooCaller
{
public:
    template <typename... Args>
    void operator () (Args&&... args) const {
        const auto v = {args...};
        for (auto x : v) std::cout << x << ' ';     std::cout << '\n';
    }

};

并保持实施：

Live Demo

Answer 2

模板不是一件事。您不能将模板函数作为函数或对象传递。现在，重载集的名称（比如，foo）可以解析为特定上下文中的模板函数的单个实例（您调用它或将其转换为函数指针），这可能是骗了你的

如果要将整个重载集作为对象使用，可以通过以下方式对其进行近似：

struct foo_f{
  template<class...Args>
  auto operator()(Args&&...args)const->
  decltype(foo(std::declval<Args>()...))
  { return foo(std::forward<Args>(args)...); }
};

现在foo_f的实例将foo的重载集近似为单个对象。通过foo_f{}代替foo。

在C ++ 14中，或者：

[](auto&&...args)->decltype(auto){return foo(decltype(args)(args)...);}

是一个lambda，其行为与上面的foo_f非常相似。

将可变参数函数作为参数

2 个答案: