Question

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

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

即：

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>(...);

OR

wrapper<superdosomething>(..);

（注意：我不想重复关于F的每个有效功能的开关声明）

Answer 1

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

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);

Answer 2

你当然不希望将F作为一个函数而是作为一个类。这样的类可以是模板类，可能具有部分或完全特化（对于类而言，对函数进行模板特化比对函数更容易）。

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

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

复杂而复杂的模板

2 个答案: