复杂而复杂的模板

Complex and convoluted templating

本文关键字：复杂      更新时间：2023-10-16

让我们从我的问题定义开始：

我

有超大的开关语句，我只想定义一次。然后，switch 语句中的每个情况都将调用一个模板化函数

即：

switch(whatever)
{
   case whatever::one:
      dosomething<char>(parameterone, parametertwo); breakl
   case whatever::two:
      dosomething<int>(parameterone, parametertwo); break;
   ... 
 }
}

这非常有效。但是，假设我想使事情复杂化。具体来说，我希望 case 语句调用两个函数，即做某事或超酷某事。

即：

template<typename F>
void wrapper(parameterone, parametertwo)
{
  switch(whatever)
  {
   case whatever::one:
      F<char>(parameterone, parametertwo); break;
   case whatever::two:
      F<int>(parameterone, parametertwo); break;
   ... 
  }
 }
}

其中 F 是某种函数指针。然后我会像这样调用包装器函数：

wrapper<dosomething>(...);

或 

wrapper<superdosomething>(..);

(注意：我真的不想为F的每个有效函数复制SWITCH语句(

是的，可以编写这样的包装器。我将使用一个可能需要根据您的实际代码进行调整的委派层。

template <class F>
void wrapper(param1, param2)
{
  switch (whatever)
  {
    case whatever::one:
      F::call<char>(param1, param2);
      break;
    case whatever::two:
      F::call<int>(param1, param2);
      break;
  }
}

struct DoSomething
{
  template <class T>
  static void call(param1, param2) { /* your code */ }
};

struct DoSomethingSuperCool
{
  template <class T>
  static void call(param1, param2) { /* your super-cool code */ }
};

用法：

wrapper<DoSomething>(p1, p2);
wrapper<DoSomethingSuperCool>(p1, p2);
当然，

您不希望将 F 作为函数，而是作为类。这样的类可以是模板类，可能具有部分或全部专用化(为类进行模板专用化比对函数进行模板专用化要容易得多(。

其他细节不太确定。该类可以有一堆静态函数，例如ProcessOne，ProcessTwo等，可以在特定的switch子句中调用。如果类有状态，它们应该是非静态的，甚至是虚拟的。实现继承将允许您使代码相对紧凑。

通常，巨大的 switch 语句是设计不太好的指标，通常可以用其他类型的调度代替，例如用虚拟功能代替。

相关文章：