C++中如何实现无内部条件判断且无代码重复的循环？

核心思路是把循环里固定不变的代码抽出来写一次，可变的逻辑（比如这里的开平方还是平方）作为参数传入。编译器会自动为不同的可变逻辑生成独立的循环代码，运行时只做一次条件判断选择对应版本，既消除了循环内的反复判断，性能和手写两个独立循环完全一致，还不用重复编写代码。

C++ 具体实现 #

1. 抽取通用循环逻辑为模板函数 #

把循环里每次执行都相同的代码（比如do_smth_1到do_smth这类操作）单独封装在模板函数里，可变的输出逻辑通过函数对象传递：

#include <iostream>
#include <vector>
#include <cmath>

// 通用循环逻辑：只写一次，可变逻辑靠参数传入
template <typename OutputFunc>
void process_vector(const std::vector<double>& vec, OutputFunc output) {
    for (const auto& i : vec) {
        do_smth_1(i);
        // ... 这里放所有固定不变的操作
        do_smth_n(i);
        
        // 执行传入的可变输出逻辑
        output(i);
        
        do_smth(i);
    }
}

// 根据运行时条件，分发到对应的循环版本
void process_with_condition(const std::vector<double>& vec, bool is_sqrt) {
    if (is_sqrt) {
        // 传递开平方的lambda，编译器会生成对应版本的process_vector
        process_vector(vec, [](double i) { std::cout << std::sqrt(i); });
    } else {
        // 传递平方的lambda，生成另一个版本的process_vector
        process_vector(vec, [](double i) { std::cout << i * i; });
    }
}

// 原代码中的辅助函数示例
void do_smth_1(double) {}
void do_smth_n(double) {}
void do_smth(double) {}

int main() {
    bool is_sqrt;
    std::cin >> is_sqrt;
    std::vector<double> vec = {1.0, 2.0, 3.0};
    process_with_condition(vec, is_sqrt);
    return 0;
}

2. 为什么这个方案有效？ #

• 编译器会自动生成两个独立的process_vector函数：一个内部直接调用std::sqrt，另一个直接执行i*i，循环内完全没有if判断。
• 运行时只在进入循环前做一次条件判断，选择对应的函数执行，性能和手写两个完全分离的循环毫无差别。
• 通用逻辑只写一遍，后续修改do_smth_1这类固定操作时，只需改动process_vector即可，不会因为重复代码漏改引发错误。

其他语言的类似实现 #

Rust #

Rust编译器会对闭包做单态化优化，生成无分支的高效代码，写法和C++思路一致：

use std::io;

fn do_smth_1(_: f64) {}
fn do_smth_n(_: f64) {}
fn do_smth(_: f64) {}

// 通用循环逻辑，接受闭包作为可变操作
fn process_vector<F: Fn(f64)>(vec: &[f64], output: F) {
    for &i in vec {
        do_smth_1(i);
        do_smth_n(i);
        output(i);
        do_smth(i);
    }
}

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let is_sqrt: bool = input.trim().parse().unwrap();
    
    let vec = vec![1.0, 2.0, 3.0];
    if is_sqrt {
        process_vector(&vec, |i| println!("{}", i.sqrt()));
    } else {
        process_vector(&vec, |i| println!("{}", i * i));
    }
}

C# #

Release模式下JIT编译器会将委托调用内联，消除分支开销，性能达到手写重复代码的水平：

using System;
using System.Collections.Generic;

class Program
{
    static void DoSmth1(double _) {}
    static void DoSmthN(double _) {}
    static void DoSmth(double _) {}

    static void ProcessVector<T>(List<double> vec, T output) where T : Action<double>
    {
        foreach (var i in vec)
        {
            DoSmth1(i);
            DoSmthN(i);
            output(i);
            DoSmth(i);
        }
    }

    static void Main()
    {
        bool isSqrt = bool.Parse(Console.ReadLine());
        var vec = new List<double> {1.0, 2.0, 3.0};
        
        if (isSqrt)
        {
            ProcessVector(vec, i => Console.WriteLine(Math.Sqrt(i)));
        }
        else
        {
            ProcessVector(vec, i => Console.WriteLine(i * i));
        }
    }
}

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