C++ 的性能优化从来不是某个孤立技巧的叠加，而是一套贯穿代码风格、编译期计算、内存布局与运行时决策的系统工程。本文提炼出 20 条可落地的高频优化“军规”，从最容易被忽视的 const 语义与移动语义，到编译器内联、分支预测和缓存友好的数据结构设计，帮助你建立一张全景的性能优化地图。每一条军规都配有简洁的示例或原因说明，方便你在日常 Code Review 或重构时直接对照。

20 条军规

军规 1：尽可能使用 const 和 constexpr

编译期常量不仅让意图更明确，还能让编译器在常量折叠、静态数组大小推断和内联展开上拥有更多优化空间。能用 constexpr 的函数和变量都尽量标记，避免把它们推到运行时才计算。

constexpr double gravity = 9.81;
constexpr int squares[] = {1, 4, 9, 16, 25};

军规 2：优先使用默认的移动语义

C++11 引入的移动语义可以避免深拷贝。如果你的类只管理普通资源，直接让编译器生成默认的移动构造函数和移动赋值运算符，而不是手写拷贝满天下的资源管理。对于返回局部对象的函数，编译器会自动尝试移动而非拷贝。

std::vector<int> createVector() {
    std::vector<int> v = {1, 2, 3};
    return v;  // 自动移动，无需 std::move
}

军规 3：在容器操作中预分配内存

对于 std::vector、std::string 等容器，反复插入导致的多次重新分配是性能黑洞。只要可以预估最终大小，就用 reserve() 一次性分配。

std::vector<int> data;
data.reserve(1000);  // 避免 10-12 次重新分配
for (int i = 0; i < 1000; ++i)
    data.push_back(i);

军规 4：慎用 std::endl，多用 '\n'

std::endl 除了插入换行符，还会强制刷新流缓冲区。频繁调用会造成不必要的 I/O 开销。省下那一句 flush()，性能差距可能在 10%~30% 的量级。

std::cout << "Hello" << '\n';   // 只换行，不刷新
// 而非 std::cout << "Hello" << std::endl;

军规 5：避免在循环中进行多余的函数调用

将不依赖循环变量的计算（如容器大小、重复的函数返回值）提到循环外部，减少每次迭代的额外负担。

auto size = vec.size();
for (size_t i = 0; i < size; ++i)  // 只调用一次 size()
    process(vec[i]);

军规 6：优先使用前置递增/递减

对于用户自定义类型，后置版本需要保存旧值并返回，代价更高。虽然整数类型在优化后通常无差别，但养成习惯能避免迭代器、智能指针等类型出现不必要的拷贝。

for (auto it = vec.begin(); it != vec.end(); ++it)  // 前置递增
    use(*it);

军规 7：用 emplace 系列函数替代 push/insert

emplace_back 和 emplace 直接在容器内部构造对象，避免了临时对象的构造和移动。当容器存储的是非平凡对象或结构体时，这一差异尤为明显。

data.emplace_back(42, "hello");  // 直接构造，无临时对象
// 而非 data.push_back(Data(42, "hello"));

军规 8：缩小数据结构的尺寸与填充顺序

调整结构体成员的声明顺序，让较大的类型靠前、较小的类型靠后，可以减少因为自然对齐而产生的内部填充，进而改善缓存行利用。

struct Bad {    // 占用 24 字节
    char a;
    double b;
    int c;
};
struct Good {   // 占用 16 字节
    double b;
    int c;
    char a;
};

军规 9：善用 noexcept 标记

将不抛出异常的函数标记为 noexcept，可以允许编译器生成更高效的代码（略去栈回退逻辑），并让 std::vector 等容器在重分配时优先使用移动而非拷贝。

void moveOp() noexcept {
    // 移动操作，保证不抛异常
}

军规 10：合理应用编译期分支 if constexpr

C++17 的 if constexpr 可以在编译期间就丢弃无效的分支，避免生成冗余的代码路径，在模板代码中尤其有用。

template <typename T>
auto getValue(const T& t) {
    if constexpr (std::is_integral_v<T>) {
        return static_cast<long long>(t);
    } else {
        return 0;
    }
}

军规 11：适当使用 [[likely]] 与 [[unlikely]]

C++20 的属性可以帮助编译器优化分支预测。当你确实知道某个分支有压倒性概率时，可以用它来引导代码布局，提高指令缓存的命中率。

if (ptr == nullptr) [[unlikely]] {
    handleError();
} else [[likely]] {
    process(*ptr);
}

军规 12：把热点代码标记为 inline 或放在头文件中

对于现代编译器，inline 的主要作用已经不是代码膨胀，而是为链接时的内联优化提供可见性。将频繁调用的小函数定义在头文件中，配合 LTO（链接时优化），能让编译器更好地消除函数调用开销。

inline int add(int a, int b) { return a + b; }

军规 13：优先使用栈分配和小对象优化

栈内存的分配与释放几乎没有开销，而堆分配涉及系统调用。对于生命周期明确且大小可控的对象，尽量使用栈变量或依赖容器内部的小对象优化（如 std::string 的 SSO）。

void process() {
    int buffer[256];           // 栈上分配
    auto f = [&](int x) {      // lambda 也是栈上的闭包对象
        buffer[0] = x;
    };
}

军规 14：理解并利用返回值优化（RVO）

编译器会自动消除返回局部对象时的拷贝，即 RVO/NRVO。不要因为害怕拷贝而把输出参数改为指针或引用。保持函数返回值的自然写法，编译器比你想的更聪明。

std::string buildName() {
    std::string name = "Hello";
    name += " World";
    return name;  // 编译器会优化掉拷贝
}

军规 15：用 std::array 替代原生数组和 small vector

std::array 既没有动态内存分配的开销，又具备标准容器接口，还能在传参时避免退化为指针，方便编译器进行边界优化和向量化。

std::array<int, 5> arr = {1, 2, 3, 4, 5};
// 安全、零开销、可迭代

军规 16：为热点数据设计缓存友好的布局

将频繁一起访问的数据放在连续内存中，使用结构体数组（AoS）或数组结构体（SoA）取决于访问模式。尽量保证顺序访问、减少指针追逐，才能喂满 CPU 的预取单元。

struct Particle { float x, y, z, vx, vy, vz; };  // AoS 适合一次更新粒子全部属性
// 或者用 SoA：struct System { std::vector<float> x, y, z; };

军规 17：减少虚函数调用与分支密集的多态

虚函数调用虽然灵活，但间接跳转难以预测，且阻止内联。在性能敏感路径中，可以考虑用模板（静态多态）或 std::variant + std::visit 替代传统的虚表。

struct Dog { void speak() const { std::cout << "Woof\n"; } };
struct Cat { void speak() const { std::cout << "Meow\n"; } };
using Animal = std::variant<Dog, Cat>;
Animal a = Dog{};
std::visit([](const auto& e) { e.speak(); }, a);

军规 18：选择合适的容器，保持“右手法则”

std::set 与 std::unordered_set 各有取舍：前者稳定有序但 O(log N)，后者 O(1) 平均但哈希开销不可忽略。对于少量有序数据，有序数组配合二分查找有时比平衡树更快。先用 std::vector 作为默认选项，基准测试后再做决定。

// 当元素数量少于几百时，vector 的线性查找可能优于 unordered_set
std::vector<int> smallSet;
if (std::binary_search(smallSet.begin(), smallSet.end(), key)) { /* ... */ }

军规 19：使用原子操作代替简单的锁

对于计数、标志位等单一共享变量的同步，std::atomic 通常比 std::mutex 开销低好几个数量级。合理的内存序（如 memory_order_relaxed）还能进一步减少屏障开销。

std::atomic<int> counter{0};
void increment() {
    counter.fetch_add(1, std::memory_order_relaxed);
}

军规 20：开启合适的编译器优化选项并测量

最后的军规是永远不要只凭直觉。启用 -O2、-O3、-march=native、连接时优化（LTO）和 Profile-Guided Optimization（PGO），并用实际的性能分析工具（perf、VTune、perf stat）确认热点。没有测量就没有优化。

// 编译示例：
// g++ -std=c++20 -O3 -march=native -flto -fprofile-use myapp.cpp

三、总结

这 20 条军规覆盖了从代码编写的一行一字符，到编译器的底层优化开关。它们不是教条，而是提醒：性能优化往往藏在风格与细节里。当你下一次遇到性能瓶颈时，不妨逐条回顾，也许其中一条就能帮你找到那个 5% 的关键加速点。记住，优秀的性能不是调出来的，是写出来的。