使用类型重构带有模板函数的 switch 语句答案

【问题标题】：Refactoring switch statement with template function using the type使用类型重构带有模板函数的 switch 语句
【发布时间】：2022-10-18 03:46:31
【问题描述】：

我正在尝试重构散布在代码库中的几个 switch-case 语句，这些语句具有以下结构：

enum Model {
  a = 1, b = 2, c = 3, d = 4, e = 5
};

function computeVal(Model m, int param1, int param2, int param3){
  Eigen::MatrixXd val, val2;

  swtich(m) {
    case Model::a:
      val = someFunc<classA>(param1, param2, param3);
      val2 = someFunc2<classA>(param1, param2, param3);
      // some more common logic
    case Model::b:
      val = someFunc<classB>(param1, param2, param3);
      val2 = someFunc2<classB>(param1, param2, param3);
      // some more common logic
    case Model::c:
      val = someFunc<classC>(param1, param2, param3);
      val2 = someFunc2<classC>(param1, param2, param3);
      // some more common logic
    case Model::d:
      val = someFunc<classD>(param1, param2, param3);
      val2 = someFunc2<classD>(param1, param2, param3);
      // some more common logic
    default:
      val = someFunc<classE>(param1, param2, param3);
      val2 = someFunc2<classE>(param1, param2, param3);
      // some more common logic
  }
}

classA、classB、classC、class D 和 classE 都继承自一个基类（Base 类）。

someFunc 和 someFunc2 初始化模板中的类并使用它。

重构它的潜在方法是什么？或者我什至应该重构这个？

我正在查看一个哈希映射/无序映射，它将模型枚举类型映射到类，但我遇到了错误。

例如。：

function computeVal(Model m, int param1, int param2, int param3) {
  std::unordered_map<int, classBase*> modelMap = {
    {Model::a, classA},
    {Model::b, classB},
    {Model::c, classC}, 
    ...
  };
  
  val = someFunc<modelMap[m]>(param1, param2, param3);
  val2 = someFunc2<modelMap[m]>(param1, param2, param3);
  // some common logic
}

我收到以下错误：expected primary-expression before '}' token。这是有道理的，因为它在初始化地图时需要对已初始化类的引用。不过，这不是我想要的。

关于如何清理这个的任何想法？

【问题讨论】：

标签： c++ switch-statement refactoring

【解决方案1】：

在与同事交谈并进行了更多研究后，共识是：

switch 语句本身不可重构

每个案例中的逻辑都可以重构为一个函数，因为它完全相同

例如

template<class LL>
function commonLogic(int param1, int param2, int param3){
  LL someClass();
  val = someFunc<someClass>(&someClass, param1, param2, param3);
  val2 = someFunc2<someClass>(&someClass, param1, param2, param3);
  // some more common logic
  
}

function computeVal(Model m, int param1, int param2, int param3){
  Eigen::MatrixXd val, val2;

  swtich(m) {
    case Model::a:
      computeVal<classA>(param1, param2, param3);
    case Model::b:
      computeVal<classB>(param1, param2, param3);
    case Model::c:
      computeVal<classC>(param1, param2, param3);
    case Model::d:
      computeVal<classD>(param1, param2, param3);
    default:
      computeVal<classE>(param1, param2, param3);
  }
}

这遵循 DRY 原则，但我可以理解为什么这只是过早的重构。

【讨论】：