是否有一种通用方法可以将函数模板改编为多态函数对象？

Question

例如，我有一些函数模板，

template <typename T>
void foo(T);

template <typename T>
void bar(T);

// others

我需要将每个模板传递给一种算法，该算法将使用各种类型调用它，例如，

template <typename F>
void some_algorithm(F f)
{
    // call f with argument of type int
    // call f with argument of type SomeClass
    // etc.
}

我无法传递未实例化的函数模板，但我也无法使用任何特定类型实例化它因为 some_algorithm 需要使用几种不同类型的参数来调用它。

我可以将我的函数模板改编为多态函数对象，例如

struct foo_polymorphic
{
    template <typename T>
    void operator()(T t)
    {
        foo(t);
    }
};

，然后将其作为 some_algorithm(foo_polymorphic()) 传递。但这需要为我的每个函数模板编写一个单独的适配器。

是否有一种通用方法将函数模板调整为多态函数对象，即我可以为我需要调整的每个函数模板重复使用某种机制，而无需单独声明某些内容对于每一个？

Answer 1

问题的简短版本被赋予一个重载名称 f，如何简洁地编写一个对象 ff 使得 ff(a0, a1, a2, ... ) 最终调用 f(a0, a1, a2, ...)。

多态函子，你如何指出自己，是通常的解决方案。但它必须被定义为不符合要求（因为它有一个模板成员），所以我认为这对于我的答案来说不够简洁。

目前 lambda 表达式产生一个单态函子，因此它们很接近，但还不够。

// set of functions overloaded on int and double
void f(int);
void f(double);

auto ff = [](int i) { return f(i); };

正如 GMan 在评论中指出的那样，多态 lambda 将（应该？）成为简洁地内联编写多态函子的解决方案。

同时，可以编写一个 make_overload 帮助器，将多个函子组合成一个，这样就

auto ff = make_overload(
    [](int arg0) { return f(arg0); }
    , [](double arg0) { return f(arg0); } );

可以“捕获”整个重载集。也许 Boost.Preprocessor 宏可以在这里提供帮助，以便内联使用 auto ff = POLYMORPHIC_LAMBDA( 1, (int)(double), { return f(arg0); } ); 。然而，我怀疑存在数量限制（因此是第一个宏参数），这与通常的外线手写多态函子解决方案不同；所以这对例如可变参数函数模板没有帮助。

Answer 2

为什么不能使用模板模板参数？你说你不能在未实例化的情况下传递你的模板，但我不确定你以前是否听说过这个，请告诉我你是否听说过，但它不会起作用。

我不知道你的代码结构是什么样的，但是你能做类似的事情吗

我知道这有效，但不知道这是否是你想要的：

template<typename T>
T some_algorithm(T data) { return T(); } // just returning nothing for example

template<typename T, T(*Something)(T)>
class FuncClass {
public:
    T run(T data) { return Something(data); }
};

template<typename T, typename Functor>
void apply_algorithm(T data) {
    Functor F;
    F.run(data);
}

int main() {
    int mydata = 4;
    apply_algorithm<int, FuncClass<int, some_algorithm<int> > >(mydata);

    cin.get();
}