C++中如何实现运行时if条件仅单次评估？

你遇到的场景很典型：循环中每次迭代的if条件结果完全相同，重复判断会带来不必要的性能开销。if constexpr依赖编译时常量，无法直接用于运行时确定的条件，但我们可以通过以下几种方式实现类似的优化效果：

方法一：提前判断条件，将结果存入常量 #

这是最直接且易读的方案，把循环内的条件判断移到循环外部，用const变量存储结果，循环内仅使用这些预计算的常量：

void MyClass::Update()
{
    // 提前评估所有条件，结果存入const变量
    const bool needUpdateStuff = (m_UpdateMode & UpdateMode_Stuff) != 0;
    const bool needUpdateSomeOtherStuff = (m_UpdateMode & UpdateMode_SomeOtherStuff) != 0;
    const bool needUpdateYetOtherStuff = (m_UpdateMode & UpdateMode_YetOtherStuff) != 0;

    for (MyOtherClass& otherClass : m_OtherClasses)
    {
        if (needUpdateStuff)
        {
            otherClass.UpdateStuff();
        }
        if (needUpdateSomeOtherStuff)
        {
            otherClass.UpdateSomeOtherStuff();
        }
        if (needUpdateYetOtherStuff)
        {
            otherClass.UpdateYetOtherStuff();
        }
    }

    m_UpdateMode = UpdateMode_None;
}

现代编译器通常会自动识别循环内不变的条件并做优化，但显式写出预判断的代码更可靠，同时也提升了可读性。

方法二：预构建操作列表，循环执行操作 #

如果条件数量较多，可以预先把需要执行的操作存入容器，循环内直接遍历执行操作，避免重复判断：

#include <functional>
#include <vector>

void MyClass::Update()
{
    std::vector<std::function<void(MyOtherClass&)>> updateOperations;

    // 仅添加需要执行的操作
    if ((m_UpdateMode & UpdateMode_Stuff) != 0)
    {
        updateOperations.push_back([](MyOtherClass& obj) { obj.UpdateStuff(); });
    }
    if ((m_UpdateMode & UpdateMode_SomeOtherStuff) != 0)
    {
        updateOperations.push_back([](MyOtherClass& obj) { obj.UpdateSomeOtherStuff(); });
    }
    if ((m_UpdateMode & UpdateMode_YetOtherStuff) != 0)
    {
        updateOperations.push_back([](MyOtherClass& obj) { obj.UpdateYetOtherStuff(); });
    }

    // 循环中仅执行预定义的操作
    for (MyOtherClass& otherClass : m_OtherClasses)
    {
        for (auto& op : updateOperations)
        {
            op(otherClass);
        }
    }

    m_UpdateMode = UpdateMode_None;
}

这种方案的优势是条件数量增加时，代码复杂度不会线性上升，缺点是存在轻微的函数调用开销（lambda的间接调用），但如果操作本身的开销远大于调用开销，这点代价可以忽略。

方法三：模板元编程+运行时分支（进阶） #

如果追求极致性能，且条件数量不多，可以结合模板生成编译时优化的执行路径，通过一次运行时分支选择对应实现：

// 模板实现：编译时通过if constexpr剔除不需要的代码
template<bool DoStuff, bool DoSomeOtherStuff, bool DoYetOtherStuff>
void UpdateImpl(std::vector<MyOtherClass>& others)
{
    for (MyOtherClass& obj : others)
    {
        if constexpr (DoStuff) obj.UpdateStuff();
        if constexpr (DoSomeOtherStuff) obj.UpdateSomeOtherStuff();
        if constexpr (DoYetOtherStuff) obj.UpdateYetOtherStuff();
    }
}

void MyClass::Update()
{
    const bool doStuff = (m_UpdateMode & UpdateMode_Stuff) != 0;
    const bool doSomeOther = (m_UpdateMode & UpdateMode_SomeOtherStuff) != 0;
    const bool doYetOther = (m_UpdateMode & UpdateMode_YetOtherStuff) != 0;

    // 运行时一次分支，选择对应的模板实例
    if (doStuff && doSomeOther && doYetOther)
    {
        UpdateImpl<true, true, true>(m_OtherClasses);
    }
    else if (doStuff && doSomeOther && !doYetOther)
    {
        UpdateImpl<true, true, false>(m_OtherClasses);
    }
    else if (doStuff && !doSomeOther && doYetOther)
    {
        UpdateImpl<true, false, true>(m_OtherClasses);
    }
    else if (!doStuff && doSomeOther && doYetOther)
    {
        UpdateImpl<false, true, true>(m_OtherClasses);
    }
    else if (doStuff)
    {
        UpdateImpl<true, false, false>(m_OtherClasses);
    }
    else if (doSomeOther)
    {
        UpdateImpl<false, true, false>(m_OtherClasses);
    }
    else if (doYetOther)
    {
        UpdateImpl<false, false, true>(m_OtherClasses);
    }
    else
    {
        UpdateImpl<false, false, false>(m_OtherClasses);
    }

    m_UpdateMode = UpdateMode_None;
}

每个模板实例中的if constexpr会在编译时移除不需要的代码，运行时只需一次分支判断即可进入完全优化的循环。缺点是条件组合会随条件数量指数增长，仅适合条件较少的场景。

为什么constexpr和if constexpr无法直接使用？ #

constexpr要求表达式在编译时即可确定值，但你的m_UpdateMode是运行时通过SomeMethod()等函数赋值的，编译时无法得知其具体值，因此无法直接用于if constexpr的条件判断。

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