C++ 性能优化实战指南 | 极客日志

C++算法

C++ 性能优化实战指南

本文介绍 C++ 性能优化方法。强调先测量后优化。包括编译期优化（如-O2, LTO）、代码级优化（减少拷贝、容器选择、循环优化、内存缓存友好性）及进阶优化（多线程、SIMD）。核心原则是定位瓶颈，避免过度优化。

神经兮兮发布于 2026/3/29更新于 2026/4/131 浏览

一、优化的前提：先测量，再优化

在开始优化前，永远不要凭感觉优化。首先要通过性能分析工具找到程序的性能瓶颈（热点），再针对性优化。

常用工具：
- Linux: perf、gprof、valgrind (callgrind)
- Windows: Visual Studio Profiler、Intel VTune
- 跨平台：Google Benchmark（代码级性能测试）

二、编译期优化（最易实施，收益高）

编译器自带的优化选项能在不修改代码的情况下大幅提升性能，是优化的第一步。

1. GCC/Clang 编译优化级别

# O0：默认，无优化（调试用）
# O1：基础优化，减少代码大小和执行时间，不增加编译时间
# O2：主流优化级别，开启几乎所有安全的优化（推荐生产环境使用）
# O3：激进优化（可能增大二进制体积，甚至引入兼容性问题）
# Os：优化代码体积（嵌入式/移动端适用）
g++ -O2 your_code.cpp -o your_program

2. 针对性编译选项

# 针对特定 CPU 架构优化（充分利用 CPU 指令集）
g++ -O2 -march=native your_code.cpp
# 自动适配当前 CPU 架构
# 开启链接时优化（LTO），跨编译单元优化
g++ -O2 -flto your_code.cpp
# 启用 C++ 最新标准（新标准可能有性能优化）
g++ -O2 -std=c++20 your_code.cpp

三、代码级优化（核心优化手段）

1. 减少不必要的拷贝（C++ 性能杀手 TOP1）

避免隐式类型转换：比如 int 和 double 混合运算会触发类型转换，增加开销。

使用移动语义（C++11+） ：对于临时对象，用 std::move 转移资源，避免拷贝：

std::vector<int> create_big_vector() {
    std::vector<int> vec(100000);
    return vec; // C++11 后自动移动，无需 std::move
}
std::vector<int> vec = create_big_vector(); // 无拷贝

使用引用（&） 或常量引用（const &） 代替值传递：

极客日志微信公众号二维码

更多推荐文章

相关免费在线工具

加密/解密文本
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。在线工具，加密/解密文本在线工具，online
Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。在线工具，Base64 文件转换器在线工具，online
Markdown 转 HTML
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。在线工具，Markdown 转 HTML在线工具，online
HTML 转 Markdown
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。在线工具，HTML 转 Markdown在线工具，online
JSON 压缩
通过删除不必要的空白来缩小和压缩JSON。在线工具，JSON 压缩在线工具，online

// 差：会拷贝整个字符串，开销大
std::string process_string(std::string s) {
    return s + "suffix";
}
// 好：无拷贝，const 保证不修改原数据
std::string process_string(const std::string& s) {
    return s + "suffix";
}

std::vector<int> vec;
vec.reserve(100000); // 提前分配 10 万空间，避免多次 realloc
for (int i = 0; i < 100000; ++i) {
    vec.push_back(i); // 无扩容开销
}

// 原循环：每次迭代处理 1 个元素
for (int i = 0; i < size; ++i) {
    sum += vec[i];
}
// 展开后：每次处理 4 个元素，减少循环次数和分支判断
int i = 0;
for (; i < size - 3; i += 4) {
    sum += vec[i] + vec[i+1] + vec[i+2] + vec[i+3];
}
// 处理剩余元素
for (; i < size; ++i) {
    sum += vec[i];
}

// 差：每次循环都计算 vec.size()（虽然 vector 的 size 是 O(1)，但其他容器可能不是）
for (int i = 0; i < vec.size(); ++i) {
    ...
}
// 好：提前计算，减少调用次数
const int size = vec.size();
for (int i = 0; i < size; ++i) {
    ...
}

// 按 64 字节对齐，避免跨缓存行访问
alignas(64) int data[16]; // 16*4=64 字节，刚好一个缓存行

// 短小函数，内联后无调用栈开销
inline int add(int a, int b) {
    return a + b;
}

// 编译期计算 10 的阶乘，运行时直接用结果
constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}
const int val = factorial(10); // 编译期确定值为 3628800

#include <thread>
#include <vector>

void process_chunk(const int* arr, int start, int end, int& result) {
    result = 0;
    for (int i = start; i < end; ++i) {
        result += arr[i];
    }
}

int parallel_sum(const int* arr, int size) {
    const int num_threads = std::thread::hardware_concurrency(); // 获取 CPU 核心数
    std::vector<std::thread> threads;
    std::vector<int> results(num_threads, 0);
    int chunk_size = size / num_threads;
    for (int i = 0; i < num_threads; ++i) {
        int start = i * chunk_size;
        int end = (i == num_threads - 1) ? size : (i + 1) * chunk_size;
        threads.emplace_back(process_chunk, arr, start, end, std::ref(results[i]));
    }
    // 等待所有线程完成
    for (auto& t : threads) t.join();
    // 合并结果
    int total = 0;
    for (int r : results) total += r;
    return total;
}

// 编译器 O3 会自动向量化这个循环（处理 int 数组求和）
#include <immintrin.h> // AVX2 头文件

int sum_vec(const int* arr, int size) {
    __m256i sum = _mm256_setzero_si256(); // 256 位寄存器，存 8 个 int
    int i = 0;
    for (; i <= size - 8; i += 8) {
        __m256i vec = _mm256_loadu_si256((__m256i*)(arr + i));
        sum = _mm256_add_epi32(sum, vec); // 8 个 int 并行相加
    }
    // 合并结果
    int res[8];
    _mm256_storeu_si256((__m256i*)res, sum);
    int total = 0;
    for (int j = 0; j < 8; ++j) total += res[j];
    // 处理剩余元素
    for (; i < size; ++i) total += arr[i];
    return total;
}