Question

有几个模板类可以使用带有一个，两个等参数的函数指针。

template <typename A1, int(*func)(A1)>
class Something1
{
public:
    static void f()
    {
        A1 a1;
        // ...
        int r = func(a1);
        // ...
    }
};

template <typename A1, typename A2, int(*func)(A1, A2)>
class Something2
{
public:
    static void f()
    {
        A1 a1;
        A2 a2;
        // ...
        int r = func(a1, a2);
        // ...
    }
};

如何编写一个模板类，可以使用指向任意数量参数的函数的指针？有可能吗？

Answer 1

您不能定义只有一个模板参数的类模板，并接受必须推导出其参数的函数指针。
要做到这一点，你必须使用这样的东西：

template<typename F, F *func>
struct S;

template<typename R, typename... A, R(*f)(A...)>
struct S<R(A...), f> {};

像这样一个非常难看的符号：

S<decltype(f), &f> s;

一种可能的替代方法是使用函数指针作为构造函数的参数：

#include<type_traits>
#include<utility>

template<typename>
struct S;

template<typename R, typename... A>
struct S<R(A...)> {
    S(R(*f)(A...)): f{f} {}
    R operator()(A... args) { return f(args...); }

private:
    R(*f)(A...);
};

void g() {}
int h(int) { return 0; }

int main() {
    S<void(void)> s1{&g};
    S<int(int)> s2{&h};
    s1();
    s2(42);
}

如果您想更进一步并拥有更灵活的解决方案，您也可以使用lambdas和工厂方法来解决它：

#include<type_traits>
#include<utility>

template<typename F>
struct S: F { S(F &&f): F{std::forward<F>(f)} {} };

template<typename F>
constexpr auto create(F &&f)
-> decltype(S<typename std::decay<F>::type>{std::forward<F>(f)}) {
    return S<typename std::decay<F>::type>{std::forward<F>(f)};
}

void g() {}
int h(int) { return 0; }

int main() {
    auto s1 = create([](){ g(); });
    auto s2 = create([](int i){ return h(i); });
    s1();
    s2(42);
}

作为旁注，如果你可以使用C ++ 14，那么最后一个片段的语法会变得更好：

#include<type_traits>
#include<utility>

template<typename F>
struct S: F { S(F &&f): F{std::forward<F>(f)} {} };

template<typename F>
constexpr auto create(F &&f) {
    return S<std::decay_t<F>>{std::forward<F>(f)};
}

void g() {}
int h(int) { return 0; }

int main() {
    auto s1 = create([](){ g(); });
    auto s2 = create([](auto&&... args){ return h(std::forward<decltype(args)>(args)...); });
    s1();
    s2(42);
}

Answer 2

使用类/结构模板专业化，可以做类似你所要求的事情。

我开发了以下SomethingN结构，而不是foo类。我已经实现了一个bar()方法，该方法会收到一个Args...列表，传递给func，一个方法baz()不接收任何内容并创建默认的构造Args...值func

#include <iostream>

template <typename F, F>
struct foo;

template <typename ... Args, int(*func)(Args...)>
struct foo<int(*)(Args...), func>
 {
   int bar (Args ... args)
    { return func(args...); }

   int baz ()
    { return func(Args{}...); }
 };


int func0 ()
 { return 0; }

int func1 (int)
 { return 1; }

int func2 (std::string const &, long)
 { return 2; }

int func3 (char, std::string const &, long)
 { return 3; }

int main ()
 {
   foo<decltype(&func0), func0>  f0;
   foo<decltype(&func1), func1>  f1;
   foo<decltype(&func2), func2>  f2;
   foo<decltype(&func3), func3>  f3;

   std::cout << f0.bar() << std::endl;                  // print 0
   std::cout << f1.bar(3) << std::endl;                 // print 1
   std::cout << f2.bar("string", 2L) << std::endl;      // print 2
   std::cout << f3.bar('c', "string", 2L) << std::endl; // print 3

   std::cout << f0.baz() << std::endl; // print 0
   std::cout << f1.baz() << std::endl; // print 1
   std::cout << f2.baz() << std::endl; // print 2
   std::cout << f3.baz() << std::endl; // print 3
 }

如何编写一个模板类而不是几个？

2 个答案: