C++ : How to programmatically define template types in runtime?

Question

我有一个要求，其中有一个枚举，并且为所有可能的枚举组合定义了模板函数，最大长度为 l。

假设枚举是

Enum typenum {A, B, C}

所有这些模板函数都是在运行时定义和可用的(即，编译器在编译时创建这些函数)

Alpha<A>::f()
Alpha<B>::f()
Alpha<C>::f()
Alpha<A,A>::f()
Alpha<A,B>::f()
Alpha<A,C>::f()
Alpha<B,A>::f()
Alpha<B,B>::f()
Alpha<B,C>::f()
Alpha<C,A>::f()
Alpha<C,B>::f()
Alpha<C,C>::f()
and combination of 3 enums, 4 enums...

现在我必须根据输入 vector 选择正确的函数

void f(vector<enum> eVec){
    Alpha::f<eVec[0], eVec[1],... eVec[eVec.size() - 1]>() // <-------

我该怎么做？一种方法是为每个尺寸定义。例如:

if(eVec.size() == 1)
   Alpha<eVec[0]>::f()
else if(eVec.size() == 2)
   Alpha<eVec[0], eVec[1]>::f()

虽然这不会扩展。是否有任何优雅、可扩展的方式来执行此操作。

Answer 1

And all these template functions are defined and available at runtime (i.e, compiler creates these functions at the compile time)

你确定这是个好主意吗？因为，如果你想选择运行时模板值，你必须执行，编译时，所有可能的Alpha<typeNumsValues...>::f()组合。如果您不对可变参数列表施加长度限制，那是不可能的，但是当限制相对较低时，计算成本也非常高。

无论如何......假设你有一个枚举如下

enum typeEnum { A, B, C };

和可变参数模板 Alpha类，有typeEnum模板值和 static方法 f()如下

template <typeEnum ...>
struct Alpha
 { static void f () { /* do something */ } };

你的f()可以调用可变参数 f_helper()

void f (std::vector<typeEnum> const & eVec)
 { f_helper<>(eVec, 0u); }

实现如下

template <typeEnum ...>
void f_helper (std::vector<typeEnum> const &, ...)
 { }

template <typeEnum ... Tes>
typename std::enable_if<(sizeof...(Tes) < 6u)>::type
    f_helper (std::vector<typeEnum> const & eVec, std::size_t index)
 {
   if ( index < eVec.size() )
      switch ( eVec[index++] )
       {
         case A: f_helper<Tes..., A>(eVec, index); break;
         case B: f_helper<Tes..., B>(eVec, index); break;
         case C: f_helper<Tes..., C>(eVec, index); break;
       }
   else
      Alpha<Tes...>::f();
 }

请注意，我对可变参数列表的长度设置了一个非常低的限制(5，sizeof...(Tes) < 6u)，因为开发的数量 Alpha呈指数级增长。

另请注意，我添加了一个不执行任何操作的 f_helper() 版本;这是必要的，因为长度小于 6 的递归调用 f_helper() ，可以使用必须以某种方式管理的 6 个枚举的可变列表来调用它。

下面是一个完整的编译示例

#include <vector>    

enum typeEnum { A, B, C };

template <typeEnum ...>
struct Alpha
 { static void f () { } };

template <typeEnum ...>
void f_helper (std::vector<typeEnum> const &, ...)
 { }

template <typeEnum ... Tes>
typename std::enable_if<(sizeof...(Tes) < 6u)>::type
    f_helper (std::vector<typeEnum> const & eVec, std::size_t index)
 {
   if ( index < eVec.size() )
      switch ( eVec[index++] )
       {
         case A: f_helper<Tes..., A>(eVec, index); break;
         case B: f_helper<Tes..., B>(eVec, index); break;
         case C: f_helper<Tes..., C>(eVec, index); break;
       }
   else
      Alpha<Tes...>::f();
 }

void f (std::vector<typeEnum> const & eVec)
 { f_helper<>(eVec, 0u); }   

int main ()
 {
   f({A, B, C, A});
 }