指令排序相关

volatile

关键字, 防止编译器对访问变量的指令进行优化，例如重新排序、合并或消除读取操作。

volatile int x;
  • 告诉编译器，每次访问 volatile 变量时，都必须从内存中重新读取，不能进行缓存或优化。
  • 主要用于多线程编程、硬件寄存器访问等场景，防止编译器假设变量不会被外部修改。

在多线程环境下，多个线程可能同时访问或修改同一个变量，如果编译器优化了对这个变量的访问，可能导致数据不一致或行为异常。在嵌入式系统中，硬件寄存器的值可能会在后台发生变化，因此必须确保对这些寄存器的访问不会被编译器优化掉。

memory_order + atomic

控制内存屏障，保证多线程环境下的指令和内存操作顺序。

#include <atomic>

std::atomic<int> x(0);
x.store(10, std::memory_order_relaxed);  // 使用不同的内存顺序

在多核处理器上，不同线程对共享变量的操作可能会被重新排序，导致不一致性。atomic 和 memory_order 确保了多线程环境下的内存可见性和执行顺序。

内存屏障

防止编译器和CPU对特定内存操作进行重新排序。

#include <atomic>
std::atomic_thread_fence(std::memory_order_seq_cst);  // 严格内存屏障

内存屏障可以阻止编译器或硬件对指令重新排序，确保操作的执行顺序符合预期，尤其在多线程和多核环境中。

asm volatile

防止编译器对特定的汇编指令进行优化或重新排序。

asm volatile("nop");  // 禁止优化此指令

std::launder

防止编译器对某些内存操作（特别是对象的重定位或placement new）进行优化。

#include <new>

int* p = new int(42);
std::launder(p);

std::launder 用于避免编译器对可能被重定位或重新构造的对象进行不安全的优化操作。

当使用 placement new 或其他低级内存操作时，编译器可能做出错误假设，std::launder 确保这些对象的合法访问。

内联函数（Inline Functions）

内联函数通过在调用处直接展开函数体，避免了函数调用的开销（如参数传递、栈帧操作）。在性能关键的代码中，尤其是小型函数的多次调用时，内联可以显著提升效率。

使用场景：

  • 小型的、频繁调用的函数。
  • 不适合大函数，因为会增大可执行文件的大小。
#include <iostream>

// 建议编译器内联
inline int square(int x) {
    return x * x;
}

__attribute__((noinline)) void bar() { /* ... */ }   // 明确禁止内联

int main() {
    int a = 5;
    std::cout << "Square of 5: " << square(a) << std::endl;
    return 0;
}

在编译时，square(a)会被替换为a * a，避免了函数调用的开销。

  • inline 关键字提示编译器可以尝试内联函数，但并非强制。编译器可以根据实际情况决定是否内联。
  • noinline 属性明确告诉编译器不允许内联，防止它对函数进行优化处理。

常量表达式（constexpr）

constexpr是C++11引入的一种机制，用来在编译期计算表达式的值。它可以用于定义常量和函数，使得结果在编译期就已经确定。通过提前计算，可以减少运行时的计算负担。

使用场景：

  • 需要在编译期确定的常量或运算。
  • 用于在模板元编程或编译期优化中提升效率。
#include <iostream>

constexpr int factorial(int n) {
    return (n <= 1) ? 1 : (n * factorial(n - 1));
}

int main() {
    constexpr int result = factorial(5); // 在编译期计算
    std::cout << "Factorial of 5: " << result << std::endl;
    return 0;
}

factorial(5)的结果在编译期计算，避免了运行时计算，直接生成常量值。

模板元编程（Template Metaprogramming）

模板元编程是C++的一种强大特性，允许在编译期执行复杂的运算。通过模板递归、constexpr和其他编译期机制，可以在编译期生成高效的代码，避免运行时开销。

使用场景：

  • 需要进行编译期复杂运算或条件判断。
  • 用于生成高效、通用的代码，避免重复的代码实现。
#include <iostream>

template<int N>
struct Factorial {
    static const int value = N * Factorial<N - 1>::value;
};

template<>
struct Factorial<1> {
    static const int value = 1;
};

int main() {
    std::cout << "Factorial of 5: " << Factorial<5>::value << std::endl;
    return 0;
}

Factorial<5>::value在编译期递归展开，计算出结果120，避免了运行时计算。

循环展开（Loop Unrolling）

循环展开是一种通过在编译期将循环体重复多次，减少循环控制逻辑的开销的优化技术。编译器会根据循环次数的固定性和大小，展开循环以减少分支跳转的代价。

使用场景：

  • 循环次数较小且固定。
  • 需要减少循环的分支跳转开销。
#include <iostream>

void sumArray(const int* arr, int size) {
    int sum = 0;
    for (int i = 0; i < size; i += 4) {
        sum += arr[i];
        sum += arr[i + 1];
        sum += arr[i + 2];
        sum += arr[i + 3];
    }
    std::cout << "Sum: " << sum << std::endl;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
    sumArray(arr, 8);
    return 0;
}

通过手动展开循环，每次迭代处理多个元素，减少了循环跳转的次数，提高了处理效率。编译器有时也会自动进行循环展开。

常量折叠（Constant Folding）

常量折叠是编译器在编译期计算常量表达式的值，并将结果直接嵌入生成的代码中，避免运行时的计算。

使用场景：

  • 常量之间的运算。
  • 用于表达式中的值在编译期就可以确定的场景。
#include <iostream>

int main() {
    int x = 2 * 3 + 5;  // 这个表达式会在编译期被计算
    std::cout << "Result: " << x << std::endl;
    return 0;
}

2 * 3 + 5的值在编译期直接计算为11，避免了运行时的计算。

条件优化（Compile-time Conditions）

利用模板或constexpr进行条件选择，允许编译期根据条件生成不同的代码路径，避免不必要的分支判断。

使用场景：

  • 条件判断可以在编译期确定。
  • 避免在运行时执行多余的分支判断。
#include <iostream>

template<bool Condition>
constexpr int choose() {
    if constexpr (Condition) {
        return 42;
    } else {
        return 0;
    }
}

int main() {
    constexpr int result = choose<true>();  // 编译期选择
    std::cout << "Result: " << result << std::endl;
    return 0;
}

if constexpr允许在编译期选择分支，未选择的分支会被完全忽略，不会生成代码。

静态断言（static_assert）

static_assert允许在编译期对某些条件进行验证，确保代码在编译阶段就捕获潜在的错误。这有助于提高代码的健壮性和优化编译期行为。

使用场景：

  • 在编译期确保某些编译条件成立。
  • 防止无效类型或错误配置进入编译流程。
#include <iostream>

template<typename T>
constexpr void checkType() {
    static_assert(sizeof(T) <= 4, "Type size is too large!");
}

int main() {
    checkType<int>();   // 编译通过
    // checkType<double>(); // 编译失败，double的大小超过4字节
    return 0;
}

static_assert在编译期进行类型检查，防止不符合要求的代码进入编译流程。

consteval和constinit

C++20 引入了两个新的关键字：consteval 和 constinit，用于改进编译时常量表达式的处理。

  • consteval：声明一个函数为 consteval，意味着这个函数只能在编译时被调用，任何试图在运行时调用它的行为都会导致编译错误。consteval 强调了编译时求值的必要性，确保调用该函数的所有表达式在编译时都能求值，增强了类型安全性。
  • constinit：当使用 constinit 声明一个变量时，编译器会确保该变量在定义时初始化，并且只允许常量表达式作为其初始值。constinit 防止了可能的未初始化常量的运行时行为，确保在使用该变量之前，它已经被初始化并且是常量的。

示例：

consteval int square(int n) {
    return n * n;
}

constinit int value = square(4);  // 确保在编译时初始化

这些特性增强了对常量表达式的控制，避免了潜在的运行时错误。