Question

我有一个TaskWrapper：

template <typename T, T (*F)(T)>
struct TaskWrapper {
  static inline T run(T clock) {
    return F(clock);
  }
};

使用它我必须指定T模板参数：

uint16_t task1(uint16_t clock) { return clock + 1; }
typedef tasks::TaskWrapper<uint16_t, task1> Task;

我想写一下：

typedef tasks::TaskWrapper<task1> Task;

让编译器弄清楚返回和参数类型是uint16_t。

注意：

TaskWrapper显然已经简化，实际上还有一些其他参数，这些参数在typedef期间传递。

包装函数只能是：

uint8_t task(uint8_t clock);
uint16_t task(uint16_t clock); // or
uint32_t task(uint32_t clock);

TaskWrapper作为模板参数传递给另一个类，它将在某个时候调用Task :: run（...）;

C ++ 11没问题。

Answer 1

仅限C ++ 17＆＃39} template <auto>功能：

template <auto F>
struct TaskWrapper {
  template <typename T>
  static inline auto run(T clock) {
    return F(clock);
  }
};

uint16_t task1(uint16_t clock) { return clock + 1; }
typedef TaskWrapper<&task1> Task; // ok

Answer 2

您可以将模板参数移动到调用的站点，但这将使其与为演绎传递的参数相对应，例如：

template <typename F, F functor>
struct TaskWrapper {
  template<typename T>
  static inline T run(T clock) {
    return functor(clock);
  }
};

uint16_t task1(uint16_t clock) { return clock + 1; }
typedef TaskWrapper<decltype(task1), task1> Task;

int main(int argc, const char * argv[])
{
  Task task;
  Task::run(10);
  return 0;
}

因此它将生成static inline int run(int clock)，它与初始函数的参数类型不同，但可能足以满足您的目的。

Answer 3

使用类型而不是值作为参数时，模板很容易。你能把你的函数转换成仿函数吗？如果是，那么可能的解决方案是：

karma run --specific-test="mySweetTest.js"

Answer 4

我不认为你可能会问到什么：如果你想将这些功能作为模板值传递，而不表达类型，你必须知道先输入;但是函数的类型是你想要推断的。

如果您接受传递函数的类型，如下所示

template <typename>
struct taskWrapper;

template <typename T>
struct taskWrapper<std::function<T(T)>>
 {
   static inline T run (std::function<T(T)> const & F, T clock)
    { return F(clock); };
 };

您可以定义定义typedef s

typedef taskWrapper<std::function<decltype(task8)>>  tsk8;
typedef taskWrapper<std::function<decltype(task16)>> tsk16;
typedef taskWrapper<std::function<decltype(task32)>> tsk32;

但您可以看到taskWrapper<std::function<decltype(task8)>>只知道task8()的类型，而不知道task8()函数本身;所以你必须把这个功能传递给run()。

以下是一个工作示例。

#include <iostream>
#include <functional>

template <typename>
struct taskWrapper;

template <typename T>
struct taskWrapper<std::function<T(T)>>
 {
   static inline T run (std::function<T(T)> const & F, T clock)
    { return F(clock); };
 };

uint8_t task8 (uint8_t clock)
 { return ++clock; }

uint16_t task16 (uint16_t clock)
 { return ++clock; }

uint32_t task32 (uint32_t clock)
 { return ++clock; }

typedef taskWrapper<std::function<decltype(task8)>>  tsk8;
typedef taskWrapper<std::function<decltype(task16)>> tsk16;
typedef taskWrapper<std::function<decltype(task32)>> tsk32;

int main ()
 {
   tsk8   t8;
   tsk16  t16;
   tsk32  t32;

   std::cout << t8.run(task8,   uint8_t(64)) << std::endl;  // print A
   std::cout << t16.run(task16, uint16_t(65)) << std::endl; // print 66
   std::cout << t32.run(task32, uint32_t(66)) << std::endl; // print 67
 }

希望这有帮助。

作为模板参数

4 个答案: