重载函数作为可变参数模板函数的参数

Question

我正在尝试创建可变参数模板函数，它接受重载函数及其参数作为参数:)

int sumall(int a) { return a; }
int sumall(int a, int b) { return a+b; }

template<typename R, typename... A>
R doit( R(*f)(A...), A... a) {
    return f(a...); }

我想在没有任何模板说明符或转换的情况下调用 doit ：

cout << doit(sumall, 7, 6) << endl

这不会编译，但是当返回类型时都是无效的，一切都很完美：

void printsum(int a) { cout << a << endl; }
void printsum(int a, int b) { cout << a+b << endl; }

template<typename... A>
void vdoit( void(*f)(A...), A... a) {
    f(a...); }

// ...
vdoit(printsum, 7, 6);

是否可以修改第一个模板以仅与 modyfing doit 模板一起使用（我想保留 sumall 函数和 doit 打电话）？我认为可以通过删除 typename R 并仅保留 template 来完成，因为 R 取决于 A ... 和 f，但我不知道如何显示这种依赖性。

Answer 1

当获取函数指针时，编译器需要知道要使用哪个重载。没有办法将指针传递给“重载集”并让编译器稍后决定。你们的示例都不适用于我尝试过的任何编译器（EDG、gcc 和 clang 的最新版本）。

我认为如果不改变通话的符号，你就不能做你想做的事。如果您愿意更改调用，您可以将有关要调用的函数的知识封装到类中，例如：

struct sumall_t {
    template <typename... T>
    auto operator()(T... args) -> decltype(sumall(args...)) {
        return sumall(args...);
    }
};

这有效地为重载集创建了一个包装器。由于结果类型无法直接推导，并且可能取决于函数的调用方式，因此您还需要使用不同版本的 doit() ：

template<typename Func, typename... A>
auto doit( Func f, A... a) ->decltype(f(a...)) {
    return f(a...);
}

然后将使用类似this：

doit(sumall_t(), 1, 2);

解决此问题的另一种方法是强制指定结果类型：以某种方式，您尝试同时做两件事：您想要推断要调用的函数的结果类型，并且您想要指导编译器进行选择结果集的特定过载。然而，这些是相互依存的。如果您删除了对从函数指针推导任何模板的任何依赖，则不需要包装重载集，因为您可以从函数的第一个参数确定重载函数的选择。如果您声称“如果返回类型不是 void，我的编译器可以做到这一点”，我会说您的编译器这样做实际上是错误的。

Answer 2

（如果您准备使用可变参数宏，请滚动到此答案的末尾以查看更好的答案，该答案使所有内容都完全可变参数。但我认为可变参数宏只是一个 g++ 扩展。）

如果您准备将函数的名称放在参数列表的末尾，那么它就可以工作。通过稍后放置，编译器可以从前面的参数中推断出必要的类型 doit：

cout << doit(7, 6, sumall) << endl;
cout << doit(10, sumall) << endl;

这是一个 ideone 上的演示。

缺点是您必须为每一数量的参数实现一个 doit。我只为一个和两个参数函数实现了它，但扩展它应该不是问题：

int sumall(int a) { return a; }
int sumall(int a, int b) { return a+b; }

template<typename A1, typename A2, typename R>
auto doit( A1 a1, A2 a2, R (*f) (A1,A2)) -> R {
    return f(a1, a2);
}
template<typename A1, typename R>
auto doit( A1 a1, R (*f) (A1)) -> R {
    return f(a1);
}

更新： 有时，您可能会觉得使用 f 作为第一个参数。但这并不像放在最后那么强大。考虑以下示例，其中 where 是两个函数，它们采用相同数量的参数，但参数类型不同。例如：

int sumall(int a, int b) { return a+b; }
string sumall(string a, string b) { return a+" "+b; }

您需要将函数作为最后一个参数，以便模板推导可以在开始时使用参数的类型和数量来推导参数的类型。这是关于 ideone 的 function-arg first 和 function-arg 最后。

将 arg 放在末尾的唯一缺点是我们无法使用可变参数模板 - 可变参数参数包必须位于末尾。而且您必须获得完全正确的类型 - 看看我如何必须使用 string("hi") 而不是简单地使用 "hi"。

使用可变参数宏获得最好的效果

通过将doit实现为宏，并使用可变参数宏（gcc/g++扩展），可以拥有完全的函数名称首先出现的可变参数解决方案。 ideone 上的演示。

cout << doit(sumall, 7, 6) << endl;
cout << doit(sumall, 10) << endl;
cout << doit(sumall, string("hi"), string("world")) << endl;

通过使用 decltype 和其他几个简单的类，我们可以使用提供的参数来推断参数的类型，然后它可以使用它从重载集中选择正确的方法并推断返回值从中输入。

template<typename ...Args>
struct OverloadResolved {
        template<typename R>
        static auto static_doit( R (*f) (Args...), Args ... args ) -> R {
                return f(args...);
        }
};

template<typename ...Args>
auto deduce(Args...) -> OverloadResolved<Args...> {
        return OverloadResolved<Args...>();
}

template<typename T>
struct dummy : public T { };

#define doit(f, ...) ( dummy<decltype(deduce( __VA_ARGS__ ))> :: static_doit(f, __VA_ARGS__) )

我很确定这是宏的安全使用，不会对任何内容进行两次评估（decltype 中的任何内容都不会实际执行。