在现代 C++ 开发中，代码优化不仅是提高程序性能的关键，还能降低资源消耗并提升用户体验。本篇文章总结了 C++ 程序员常用的代码优化技巧，并附带相关的代码示例。

1. 编译器优化

利用编译器的优化选项可以显著提升程序性能。例如，使用 GCC 或 Clang 时，可以启用 -O2 或 -O3：

g++ -O3 -o optimized_program program.cpp

此外，Profile-Guided Optimization (PGO) 可以根据程序运行时的行为进行优化。

2. 数据结构优化

选择合适的数据结构是优化的基础。以下是一个选择合适 STL 容器的例子：

示例：使用 std::vector 替代 std::list

#include <vector>
#include <list>
#include <iostream>
#include <chrono>

void testVector() {
    std::vector<int> vec;
    for (int i = 0; i < 1000000; ++i) {
        vec.push_back(i);
    }
}

void testList() {
    std::list<int> lst;
    for (int i = 0; i < 1000000; ++i) {
        lst.push_back(i);
    }
}

int main() {
    auto start = std::chrono::high_resolution_clock::now();
    testVector();
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "Vector time: " << std::chrono::duration<double>(end - start).count() << "s\n";

    start = std::chrono::high_resolution_clock::now();
    testList();
    end = std::chrono::high_resolution_clock::now();
    std::cout << "List time: " << std::chrono::duration<double>(end - start).count() << "s\n";
    return 0;
}

分析：
std::vector 的连续内存布局更友好于 CPU 缓存，而 std::list 的链表结构会导致大量指针跳转，因此性能较低。

3. 内存优化

示例：减少动态内存分配

#include <iostream>
#include <vector>

void allocateMemoryEfficiently() {
    std::vector<int> vec;
    vec.reserve(1000);  // 提前分配足够的空间
    for (int i = 0; i < 1000; ++i) {
        vec.push_back(i);
    }
}

void allocateMemoryInefficiently() {
    std::vector<int> vec;  // 未提前分配空间
    for (int i = 0; i < 1000; ++i) {
        vec.push_back(i);  // 可能多次触发重新分配
    }
}

分析：
通过 reserve 提前分配空间，可以避免多次重新分配内存的开销。

4. 算法优化

示例：避免重复计算

#include <iostream>
#include <vector>

int fibonacci(int n, std::vector<int>& memo) {
    if (n <= 1) return n;
    if (memo[n] != -1) return memo[n];
    return memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
}

int main() {
    int n = 40;
    std::vector<int> memo(n + 1, -1);
    std::cout << "Fibonacci(" << n << ") = " << fibonacci(n, memo) << "\n";
    return 0;
}

分析：
通过动态规划避免了递归中的重复计算，将复杂度从指数级降低到线性级。

5. 函数调用优化

示例：内联函数

#include <iostream>

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

int main() {
    int x = 10, y = 20;
    std::cout << "Sum: " << add(x, y) << "\n";
    return 0;
}

分析：
内联函数在编译时直接展开，避免了函数调用的开销。

6. 使用现代 C++ 特性

示例：移动语义

#include <iostream>
#include <vector>

std::vector<int> createLargeVector() {
    std::vector<int> vec(1000000, 42);
    return vec;  // 移动语义避免了拷贝
}

int main() {
    std::vector<int> myVec = createLargeVector();
    std::cout << "Vector size: " << myVec.size() << "\n";
    return 0;
}

分析：
通过移动语义（C++11 的特性），大对象在返回时避免了深拷贝，从而提高性能。

7. 循环优化

示例：循环展开

#include <iostream>

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

分析：
循环展开减少了循环控制语句的开销，有助于提高性能。

8. 缓存友好性

示例：提高数据局部性

#include <iostream>
#include <vector>

void cacheFriendlyAccess(const std::vector<std::vector<int>>& matrix) {
    int sum = 0;
    for (size_t i = 0; i < matrix.size(); ++i) {
        for (size_t j = 0; j < matrix[i].size(); ++j) {
            sum += matrix[i][j];  // 按行访问，缓存友好
        }
    }
    std::cout << "Sum: " << sum << "\n";
}

分析：
按行访问（连续内存）比按列访问更高效，因为它充分利用了缓存局部性。

9. 多线程优化

示例：并行加速

#include <iostream>
#include <vector>
#include <thread>

void partialSum(const std::vector<int>& data, int start, int end, long long& result) {
    result = 0;
    for (int i = start; i < end; ++i) {
        result += data[i];
    }
}

int main() {
    std::vector<int> data(1000000, 1);
    long long sum1 = 0, sum2 = 0;

    std::thread t1(partialSum, std::cref(data), 0, data.size() / 2, std::ref(sum1));
    std::thread t2(partialSum, std::cref(data), data.size() / 2, data.size(), std::ref(sum2));

    t1.join();
    t2.join();

    std::cout << "Total sum: " << sum1 + sum2 << "\n";
    return 0;
}

分析：
利用多线程可以显著提升计算密集型任务的执行效率。

结论

优化 C++ 程序需要结合实际场景，选择合适的数据结构、算法和现代语言特性。同时，借助性能剖析工具（如 gprof、perf）定位瓶颈点，将优化集中在关键代码路径上，才能事半功倍。