【问题标题】:How to have a pointer to a function with arbitrary arguments as a template parameter?如何将指向具有任意参数的函数的指针作为模板参数?
【发布时间】:2013-05-26 15:25:54
【问题描述】:

这是我过去几天一直在研究的语义优化问题,但我陷入了困境。我的真实程序在 RTOS(特别是 FreeRTOS)上运行,我需要生成任务(这是简化的、非终止版本的线程)。 C API 采用void (*)(void*) 作为任务的入口点,并采用void* 参数。相当标准的票价。

我已经为一个任务编写了一个包装类,我宁愿让 C++ 来生成必要的通过可变参数模板和函数来存储参数对象和粘合函数。

我已经用 lambdas 和 std::function 和 std::bind 完成了这项工作,但它们似乎实现了一些膨胀,即直到运行时才解析函数目标。基本上与虚拟方法使用的机制相同。如果可能的话,我正在努力减少所有开销。与硬编码实现相比,每个实例的膨胀已达到约 200 字节。 (这是在具有 128K 总闪存的 ARM Cortex-M3 上,我们只剩下大约 500 个字节。)我发现的关于该主题的所有 SO 问题同样将函数的解析推迟到运行时。

这个想法是让代码:

  1. 将可变参数的衰减版本存储在堆上分配的对象中(这是一种简化;可以使用分配器代替),并将其作为void* 参数传递,
  2. 将生成的调用岛函数作为入口点传递,带有签名void(void*),它使用存储的参数调用目标函数,并且
  3. (这是我想不通的部分)让编译器从目标函数的签名中推断出参数列表的类型,以遵循 Don't Repeat Yourself 原则。李>
  4. 请注意,函数指针及其参数类型在编译时是已知和解析的,并且实际的传递给函数的参数值直到运行时才知道(因为它们包括对象指针和运行时配置选项)。

在下面的示例中,当 我宁愿写 Task<bar> task_bar(100); 或 Task task_bar<bar>(100); 并让编译器弄清楚(或以某种方式告诉它)时,我必须将其中一项任务实例化为 Task<void (*)(int), bar, int> task_bar(100);在库中),可变参数必须匹配指定函数的参数列表。

“显而易见”的答案将是某种模板签名,例如template<typename... Args, void (*Function)(Args...)>,但不用说,它不会编译。 Function 是第一个参数的情况也不是。

我不确定这是否可能,所以我在此请求看看你们的想法。为了简化问题,我省略了针对对象方法而不是静态函数的变体代码。

以下是一个有代表性的测试用例。我正在使用 gcc 4.7.3 和 -std=gnu++11 标志构建它。

#include <utility>
#include <iostream>
using namespace std;

void foo() { cout << "foo()\n"; }
void bar(int val) { cout << "bar(" << val << ")\n"; }

template<typename Callable, Callable Target, typename... Args>
struct TaskArgs;

template<typename Callable, Callable Target>
struct TaskArgs<Callable, Target> {
    constexpr TaskArgs() {}
    template<typename... Args>
    void CallFunction(Args&&... args) const
    { Target(std::forward<Args>(args)...); }
};

template<typename Callable, Callable Target, typename ThisArg, 
    typename... Args>
struct TaskArgs<Callable, Target, ThisArg, Args...> {
    typename std::decay<ThisArg>::type arg;
    TaskArgs<Callable, Target, Args...> sub;
    constexpr TaskArgs(ThisArg&& arg_, Args&&... remain)
    : arg(arg_), sub(std::forward<Args>(remain)...) {}
    template<typename... CurrentArgs>
    void CallFunction(CurrentArgs&&... args) const
    { sub.CallFunction(std::forward<CurrentArgs>(args)..., arg); }
};

template<typename Callable, Callable Target, typename... Args>
struct TaskFunction {
    TaskArgs<Callable, Target, Args...> args;
    constexpr TaskFunction(Args&&... args_)
    : args(std::forward<Args>(args_)...) {}
    void operator()() const { args.CallFunction(); }
};

// Would really rather template the constructor instead of the whole class.
// Nothing else in the class is virtual, either.
template<typename Callable, Callable Entry, typename... Args>
class Task {
public:
    typedef TaskFunction<Callable, Entry, Args...> Function;
    Task(Args&&... args): taskEntryPoint(&Exec<Function>), 
        taskParam(new Function(std::forward<Args>(args)...)) { Run(); }
    template<typename Target>
    static void Exec(void* param) { (*static_cast<Target*>(param))(); }
    // RTOS actually calls something like Run() from within the new task.
    void Run() { (*taskEntryPoint)(taskParam); }
private:
    // RTOS actually stores these.
    void (*taskEntryPoint)(void*);
    void* taskParam;
};

int main()
{
    Task<void (*)(), foo> task_foo;
    Task<void (*)(int), bar, int> task_bar(100);
    return 0;
}

【问题讨论】:

  • 您唯一能做的就是Task&lt;decltype(foo), foo&gt; 使用您当前的设置。不过,我的问题是 - 为什么将函数指针作为模板参数?如果你摆脱了这个要求,你可以做auto tfoo = make_task(foo); 全额扣除。
  • 你可能想看看here。
  • 当 typedef 和 param 可以使用时为什么要使用模板?
  • 我想我知道我错过了什么。您需要 C++14/17 功能,即能够将类型参数推断为 template。 Task&lt;decltype(&amp;foo), foo&gt;,如果您不喜欢输入两次foo,您可以通过宏来完成,这是您在 C++11 中必须执行的方式。在 C++14 或 17 中,它们将能够从以后的非类型参数类型中推导出 template 的类型参数。
  • 哦,我应该提一个不太极端的解决方案:template&lt;typename Callable, Callable Entry&gt; class Task; template&lt;typename R, typename... Args, R(*Entry)(Args...)&gt; class Task&lt;R(Args...), Entry&gt; { /* old body */ };,它可以让你从函数的类型中推断出Args。这就是decltype cmets 的意义所在。您创建一个不存在的基本实现,然后专门用于模式匹配 Args...

标签: c++ c++11 callback variadic-templates variadic-functions


【解决方案1】:

一些元编程样板开始:

template<int...> struct seq {};
template<int Min, int Max, int... s> struct make_seq:make_seq<Min, Max-1, Max-1, s...> {};
template<int Min, int... s> struct make_seq<Min, Min, s...> {
  typedef seq<s...> type;
};
template<int Max, int Min=0>
using MakeSeq = typename make_seq<Min, Max>::type;

帮助解包元组:

#include <tuple>
template<typename Func, Func f, typename Tuple, int... s>
void do_call( seq<s...>, Tuple&& tup ) {
  f( std::get<s>(tup)... );
}

结果函数指针的类型:

typedef void(*pvoidary)(void*);

真正的主力。注意不会产生虚函数开销:

template<typename FuncType, FuncType Func, typename... Args>
std::tuple<pvoidary, std::tuple<Args...>*> make_task( Args&&... args ) {
  typedef std::tuple<Args...> pack;
  pack* pvoid = new pack( std::forward<Args>(args)... );
  return std::make_tuple(
    [](void* pdata)->void {
      pack* ppack = reinterpret_cast<pack*>(pdata);
      do_call<FuncType, Func>( MakeSeq<sizeof...(Args)>(), *ppack );
    },
    pvoid
  );
}

这是一个删除一些decltype 样板的宏。在 C++17(也许是 14)中,这不应该是必需的,我们可以从第二个参数推断出第一个参数:

#define MAKE_TASK( FUNC ) make_task< typename std::decay<decltype(FUNC)>::type, FUNC >

测试工具:

#include <iostream>

void test( int x ) {
  std::cout << "X:" << x << "\n";
}
void test2( std::string s ) {
  std::cout << "S:" << s.c_str() << "\n";
}
int main() {
  auto task = MAKE_TASK(test)( 7 );
  pvoidary pFunc;
  void* pVoid;
  std::tie(pFunc, pVoid) = task;
  pFunc(pVoid);
  delete std::get<1>(task); // cleanup of the "void*"
  auto task2 = MAKE_TASK(test2)("hello");
  std::tie(pFunc, pVoid) = task2;
  pFunc(pVoid);
  delete std::get<1>(task2); // cleanup of the "void*"
}

Live version

而且,为了后代,我的第一次刺,这很有趣,但错过了标记: Old version(它对要调用的函数进行运行时绑定,导致对voidary函数的调用不可避免地进行了两次调用)

一个小问题——如果你没有 std::move 将参数引入任务(或者在该调用中引入 move,比如使用临时对象),你最终会得到对它们的引用而不是副本其中void*.

【讨论】:

  • 实际上,我之前使用过 lambdas。这是我试图改进的代码臃肿的情况,因为使用 lambda 会导致两件事:1)实际上与两个编译器生成的具有虚函数的类相同:一个只有 virtual void lambda(void) = 0 的抽象和第二个 final具有实现的类,以及 2) 需要“抛出 bad_func”函数(即使使用 -fno-exceptions),类似于您必须定义 __cxa_pure_virtual 以处理纯虚拟调用的方式。我设法#pragma weak #2 获得了我所拥有的东西,但不是来自 #1 的 vtbl 膨胀。
  • 顺便说一句,lambda 版本真的很简单:Task 构造函数只接受了一个通过参数传递的std::function&lt;void()&gt;。然后调用者只是传递了[&amp;](){myTask(x, y, z);}之类的东西。
  • @MikeDeSimone 我重写了它,上面是第 3 版。std::function&lt;void()&gt; 在第 2 版中被淘汰,因为正如您所指出的那样,这是一个 virtual 函数开销。 Lambda 并不意味着 std::function -- std::function 是 Lambda 之上的类型擦除。上面应该在编译时绑定函数指针,并在运行时传递参数。我可能应该返回一个std::tuple&lt;...&gt;*,所以删除它是安全的,让我修复它。
  • @MikeDeSimone 版本 3 添加了您传入的函数“指针”的编译时解析。虽然 MAKE_TEST(test) 看起来像一个函数调用,但您会注意到它解析为将 test 传递给仅限template。
  • 实际上,FreeRTOS 并没有真正有组织的方法来删除任务。当你删除一个任务(如果删除一个任务的选项甚至被启用),它只是吹走它的上下文并在那里堆栈。没有机会清理。因此,正确的删除支持几乎是学术性的。
猜你喜欢
  • 2010-11-19
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2021-12-10
  • 1970-01-01
  • 2014-04-14
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多