C++优化：提速占70%耗时的switch-if-else阶梯代码

• 业务代码以执行速度为最高优先级，通过std::chrono库的high_resolution_clock()做性能观测发现，嵌套if-else阶梯的switch()结构占用了超过70%的总执行时间
• 编译环境为gcc，已开启-O3最高优化等级
• 无法使用return语句提前退出做优化：return会直接退出外层不允许中断的循环

原代码如下：

switch(RPL_OPTION) {
    case 0:
        for(int k = 0; k < WINDOW_SIZE; k++) {
            if(ans[k] >= upper_th) {
                flag_count++;
                filtered_output.push_back(ans[k]);
                flag_output.push_back(1);

            } else if(ans[k] < lower_th) {
                flag_count++;
                filtered_output.push_back(ans[k]);
                flag_output.push_back(1);

            } else {
                filtered_output.push_back(ans[k]);
                flag_output.push_back(0);
            }
        }
        break;
    case 1:
        for(int k = 0; k < WINDOW_SIZE; k++) {
            if(ans[k] >= upper_th) {
                flag_count++;
                filtered_output.push_back(RPL_CONST);
                flag_output.push_back(1);

            } else if(ans[k] < lower_th) {
                flag_count++;
                filtered_output.push_back(RPL_CONST);
                flag_output.push_back(1);

            } else {
                filtered_output.push_back(ans[k]);
                flag_output.push_back(0);
            }
        }
        break;
    case 2:
        for(int k = 0; k < WINDOW_SIZE; k++) {
            if(ans[k] >= upper_th) {
                flag_count++;
                filtered_output.push_back(upper_th);
                flag_output.push_back(1);

            } else if(ans[k] < lower_th) {
                flag_count++;
                filtered_output.push_back(lower_th);
                flag_output.push_back(1);

            } else {
                filtered_output.push_back(ans[k]);
                flag_output.push_back(0);
            }
        }
        break;
    case 3:
        default_random_engine generator(time(0));
        normal_distribution<float> dist(0,1);

        for(int k = 0; k < WINDOW_SIZE; k++) {
            if(ans[k] >= upper_th) {
                flag_count++;
                filtered_output.push_back(dist(generator)*sigma);
                flag_output.push_back(1);
                continue;

            } else if(ans[k] < lower_th) {
                flag_count++;
                filtered_output.push_back(dist(generator)*sigma);
                flag_output.push_back(1);
                continue;

            } else {
                filtered_output.push_back(ans[k]);
                flag_output.push_back(0);
            }
        }
        break;
}

按收益从高到低排序：

• 消除vector动态扩容开销：所有分支每次处理固定WINDOW_SIZE个元素，进入逻辑前先给两个输出vector预分配内存：

  filtered_output.reserve(filtered_output.size() + WINDOW_SIZE);
  flag_output.reserve(flag_output.size() + WINDOW_SIZE);
  

  push_back触发的频繁内存重分配、数据拷贝是热点代码里非常常见的性能杀手，这步改动通常能拿到20%~50%的性能提升。
• 移除随机数生成器的重复初始化逻辑：case3中每次进入分支都重新创建default_random_engine、调用time(0)初始化、重建正态分布对象的开销极高。把随机数生成器、分布对象移到分支外（甚至整个处理逻辑的初始化阶段）一次性创建，不要每次进case3都重建，这部分在case3命中时能带来数倍的性能提升，还能避免秒级时间戳导致的随机数重复问题。建议用高精度时间戳做随机数种子，避免time(0)精度不足的问题。
• 合并冗余分支判断：四个case里的循环逻辑90%是重复的，核心判断只有「当前值是否超出[lower_th, upper_th]区间」，两个越界分支除了写入filtered_output的值不同，其余逻辑（flag_count累加、flag_output写1）完全一致。把整个循环提到switch外层，循环内只做一次越界判断，越界时再根据RPL_OPTION选择要写入的值即可，把原来的12个分支压缩到2个分支，大幅降低分支预测失败的开销。重构后的核心逻辑框架如下：

  // 提前预分配内存
  filtered_output.reserve(filtered_output.size() + WINDOW_SIZE);
  flag_output.reserve(flag_output.size() + WINDOW_SIZE);
  
  // case3的随机数生成器提前初始化，不要放循环内
  // static default_random_engine generator(chrono::steady_clock::now().time_since_epoch().count());
  // static normal_distribution<float> dist(0,1);
  
  for(int k = 0; k < WINDOW_SIZE; k++) {
      const float val = ans[k];
      const bool is_outlier = (val >= upper_th) || (val < lower_th);
      if (is_outlier) {
          flag_count++;
          flag_output.push_back(1);
          float out_val;
          switch(RPL_OPTION) {
              case 0: out_val = val; break;
              case 1: out_val = RPL_CONST; break;
              case 2: out_val = val >= upper_th ? upper_th : lower_th; break;
              case 3: out_val = dist(generator)*sigma; break;
          }
          filtered_output.push_back(out_val);
      } else {
          flag_output.push_back(0);
          filtered_output.push_back(val);
      }
  }
  

• 优化分支选择逻辑：如果RPL_OPTION是编译期可确定的常量，直接用C++17的if constexpr代替运行时switch，编译器会直接裁剪掉所有无效分支，生成无多余判断的最优代码；如果是运行时变量，可以把四个case的输出值逻辑存成函数指针数组，索引直接对应RPL_OPTION的值，避免循环内每次switch判断的开销。
• 移除冗余代码、辅助编译器优化：删掉case3里多余的continue语句（分支执行完自然会进入下一轮循环，多余的continue会干扰GCC的指令调度和自动矢量化判断）；如果WINDOW_SIZE是编译期常量，可以加#pragma GCC unroll 8（根据CPU缓存、向量宽度调整展开系数）提示GCC做循环展开，减少循环计数判断的开销，提升指令并行度。
• 触发自动矢量化优化：合并分支后的线性循环逻辑非常规整，GCC在-O3下会自动识别做SIMD矢量化，批量处理阈值判断、数据写入，相比标量逻辑通常能拿到2~4倍的性能提升。可以给ans数组加__restrict__修饰符，告诉编译器该指针没有别名，进一步辅助矢量化优化。

内容的提问来源于stack exchange，提问作者Psynapse_261