编辑“︁C++ 代码优化”︁（章节）

= C++代码优化 =

== 介绍 ==
'''C++代码优化'''是指通过改进代码结构、算法选择或编译器设置等手段，提升程序执行效率、减少资源消耗的过程。优化目标通常包括：
* 提高运行速度
* 减少内存占用
* 降低功耗（嵌入式系统）
* 提高代码可维护性

优化需要在正确性和性能之间取得平衡，应始终在确保功能正确的前提下进行。

== 优化层次 ==
C++优化可分为多个层次：

<mermaid>
graph TD
    A[代码优化] --> B[算法优化]
    A --> C[数据结构选择]
    A --> D[编译器优化]
    A --> E[硬件特性利用]
    B --> B1[时间复杂度降低]
    C --> C1[缓存友好结构]
    D --> D1[编译器指令]
    E --> E1[SIMD指令]
</mermaid>

== 基础优化技巧 ==

=== 避免不必要的拷贝 ===
使用引用和移动语义减少对象拷贝：

<syntaxhighlight lang="cpp">
// 非优化版本
std::vector<std::string> processStrings(std::vector<std::string> input) {
    std::vector<std::string> result;
    for (auto s : input) {  // 这里发生拷贝
        result.push_back(s); // 这里又发生拷贝
    }
    return result; // 可能发生拷贝（取决于编译器优化）
}

// 优化版本
std::vector<std::string> processStrings(const std::vector<std::string>& input) {
    std::vector<std::string> result;
    result.reserve(input.size()); // 预分配内存
    for (const auto& s : input) { // 使用引用避免拷贝
        result.emplace_back(s);   // 使用emplace_back避免临时对象
    }
    return result; // 编译器会进行返回值优化（RVO）
}
</syntaxhighlight>

=== 循环优化 ===
关键技巧：
* 减少循环内部的计算
* 展开循环（编译器通常自动处理）
* 避免循环内的分支预测失败

<syntaxhighlight lang="cpp">
// 非优化版本
for (int i = 0; i < n; ++i) {
    a[i] = b[i] * std::sin(angle); // 每次循环计算sin
}

// 优化版本
const double sin_val = std::sin(angle); // 提前计算
for (int i = 0; i < n; ++i) {
    a[i] = b[i] * sin_val;
}
</syntaxhighlight>

== 高级优化技术 ==

=== 内存访问优化 ===
现代CPU性能受内存访问模式影响极大。原则：
* 顺序访问优于随机访问
* 利用缓存局部性

<mermaid>
graph LR
    A[CPU寄存器] --> B[L1缓存]
    B --> C[L2缓存]
    C --> D[L3缓存]
    D --> E[主内存]
    E --> F[磁盘]
</mermaid>

示例：二维数组访问优化

<syntaxhighlight lang="cpp">
const int SIZE = 1024;
double arr[SIZE][SIZE];

// 非优化版本（列优先，缓存不友好）
for (int j = 0; j < SIZE; ++j) {
    for (int i = 0; i < SIZE; ++i) {
        arr[i][j] = 0.0;
    }
}

// 优化版本（行优先，缓存友好）
for (int i = 0; i < SIZE; ++i) {
    for (int j = 0; j < SIZE; ++j) {
        arr[i][j] = 0.0;
    }
}
</syntaxhighlight>

=== 编译器优化标志 ===
常用GCC/Clang优化选项：
* <code>-O1</code>：基本优化
* <code>-O2</code>：推荐级别优化
* <code>-O3</code>：激进优化（可能增加代码大小）
* <code>-march=native</code>：针对本地CPU优化

== 性能分析工具 ==
优化前应先使用工具定位瓶颈：
* **gprof**：GNU性能分析工具
* **perf**：Linux系统性能分析
* **Valgrind**：内存和调用分析
* **VTune**：Intel性能分析器

== 数学优化 ==
对于数值计算密集型代码，数学公式优化可带来显著提升。例如：

计算多项式值：
<math>
P(x) = a_0 + a_1x + a_2x^2 + a_3x^3 + \cdots + a_nx^n
</math>

使用霍纳法则（Horner's method）优化：
<math>
P(x) = a_0 + x(a_1 + x(a_2 + x(a_3 + \cdots + x(a_{n-1} + x a_n)\cdots)))
</math>

C++实现：
<syntaxhighlight lang="cpp">
// 普通多项式计算
double polynomial(const std::vector<double>& coeffs, double x) {
    double result = 0.0;
    for (int i = 0; i < coeffs.size(); ++i) {
        result += coeffs[i] * std::pow(x, i);
    }
    return result;
}

// 霍纳法则优化
double polynomial_horner(const std::vector<double>& coeffs, double x) {
    double result = 0.0;
    for (int i = coeffs.size() - 1; i >= 0; --i) {
        result = result * x + coeffs[i];
    }
    return result;
}
</syntaxhighlight>

== 实际案例：图像处理优化 ==
考虑图像卷积操作优化：

原始实现：
<syntaxhighlight lang="cpp">
void applyKernel(const Image& src, Image& dst, const Kernel& kernel) {
    for (int y = 1; y < src.height-1; ++y) {
        for (int x = 1; x < src.width-1; ++x) {
            float sum = 0.0f;
            for (int ky = -1; ky <= 1; ++ky) {
                for (int kx = -1; kx <= 1; ++kx) {
                    sum += src.at(x+kx, y+ky) * kernel.at(1+kx, 1+ky);
                }
            }
            dst.at(x,y) = sum;
        }
    }
}
</syntaxhighlight>

优化方向：
1. 循环展开内层kx,ky循环
2. 使用SIMD指令并行计算
3. 分块处理提高缓存利用率

== 优化原则 ==
1. '''先测量，后优化'''：使用性能分析工具定位真正瓶颈
2. '''80/20法则'''：大部分时间花费在少量代码上
3. '''可读性优先'''：除非必要，不要牺牲代码清晰度
4. '''算法优先'''：好的算法比微观优化更有效

== 编译器优化限制 ==
编译器无法优化的场景：
* 跨函数边界的优化受限
* 指针别名问题
* 虚函数调用
* 有副作用的表达式

使用<code>restrict</code>关键字（C99）或<code>__restrict</code>扩展可帮助编译器优化：

<syntaxhighlight lang="cpp">
void addArrays(int* __restrict a, int* __restrict b, int* __restrict c, int n) {
    for (int i = 0; i < n; ++i) {
        a[i] = b[i] + c[i]; // 编译器知道a,b,c不重叠，可激进优化
    }
}
</syntaxhighlight>

== 总结 ==
C++代码优化是一个多层次的过程，需要：
* 理解计算机体系结构
* 掌握性能分析工具
* 了解编译器能力与限制
* 平衡性能与代码可维护性

记住Donald Knuth的名言："过早优化是万恶之源"。应在正确性得到保证后，针对实际性能瓶颈进行优化。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 最佳实践]]