C++ 性能优化实操：内存、CPU 与 I/O 的优化方法

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

void preallocateMemory() {
    const int size = 10000;
    std::vector<int> vec;
    vec.reserve(size); // 预分配
    for (int i = 0; i < size; ++i) {
        vec.push_back(i);
    }
}

void notPreallocateMemory() {
    const int size = 10000;
    std::vector<int> vec;
    for (int i = 0; i < size; ++i) {
        vec.push_back(i);
    }
}

int main() {
    auto start = std::chrono::high_resolution_clock::now();
    preallocateMemory();
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "预分配耗时：" 
              << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() 
              << "微秒" << std::endl;
    return 0;
}

实际测试中，预分配版本在10000个int的场景下通常快一倍以上。

CPU 优化

循环合并与缓存友好

多次遍历数组会反复触发缓存未命中，把相关操作合并到一个循环里能提高数据局部性。

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

void optimizedLoop() {
    const int size = 10000;
    std::vector<int> vec1(size, 1);
    std::vector<int> vec2(size, 2);
    std::vector<int> result(size, 0);
    for (int i = 0; i < size; ++i) {
        result[i] = vec1[i] + vec2[i]; // 一次遍历完成加法
    }
}

void unoptimizedLoop() {
    const int size = 10000;
    std::vector<int> vec1(size, 1);
    std::vector<int> vec2(size, 2);
    std::vector<int> result(size, 0);
    for (int i = 0; i < size; ++i) result[i] = vec1[i];
    for (int i = 0; i < size; ++i) result[i] += vec2[i]; // 两次遍历
}

int main() {
    auto start = std::chrono::high_resolution_clock::now();
    optimizedLoop();
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "优化循环耗时：" 
              << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() 
              << "微秒" << std::endl;
    return 0;
}

这里优化的效果在小规模数据上不太明显，但数据量增大后优势会显现。

内联函数减少调用开销

对于高频调用的短函数，用inline可以省去栈帧建立和返回的开销，虽然在现代编译器优化下不一定有肉眼可见的差距，但习惯上能帮助编译器决策。

#include <iostream>
#include <chrono>

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

int addNotInline(int a, int b) {
    return a + b;
}

void testFunctionCallOverhead() {
    const int size = 1000000;
    int result = 0;
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < size; ++i) {
        result += add(i, i);
    }
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "内联函数调用耗时：" 
              << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() 
              << "微秒" << std::endl;
}

int main() {
    testFunctionCallOverhead();
    return 0;
}

I/O 操作

文件 I/O 缓冲

默认流是缓冲的，一般够用，但在大批量写入时显式控制缓冲区或许能调整吞吐。频繁地打开关闭文件反而是更常见的坑。

#include <iostream>
#include <fstream>
#include <chrono>

void optimizedFileIO() {
    const std::string filename = "test.txt";
    const int size = 10000;
    std::ofstream file(filename);
    // 默认缓冲即可，这里仅作演示
    for (int i = 0; i < size; ++i) {
        file << i << std::endl;
    }
    file.close();
}

int main() {
    auto start = std::chrono::high_resolution_clock::now();
    optimizedFileIO();
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "文件 I/O 耗时：" 
              << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() 
              << "毫秒" << std::endl;
    return 0;
}

网络 I/O 异步处理

同步网络调用会锁住线程，用Boost.Asio这类库实现异步读写可以大幅提升并发能力。

#include <iostream>
#include <boost/asio.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/streambuf.hpp>
#include <sstream>

using boost::asio::ip::tcp;

void optimizedNetworkIO() {
    try {
        boost::asio::io_service io_service;
        tcp::resolver resolver(io_service);
        tcp::resolver::query query("example.com", "http");
        tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
        tcp::socket socket(io_service);
        boost::asio::connect(socket, endpoint_iterator);
        
        std::string request = "GET / HTTP/1.1\r\n";
        request += "Host: example.com\r\n";
        request += "Connection: close\r\n\r\n";
        
        boost::asio::write(socket, boost::asio::buffer(request));
        boost::asio::streambuf response;
        boost::asio::read_until(socket, response, "\r\n");
        
        std::istream is(&response);
        std::string status_line;
        is >> status_line;
    } catch (const std::exception& e) {
        std::cerr << "错误：" << e.what() << std::endl;
    }
}

int main() {
    optimizedNetworkIO();
    return 0;
}

综合案例：矩阵乘法优化

矩阵乘法是考察缓存利用的经典例子。朴素的三层循环会在内层反复跳跃式访问数据，而转置第二个矩阵后可以利用顺序访问大幅减少缓存缺失。

项目结构

MatrixMultiplicationOptimization/
├── include/
│   └── Matrix.h
├── src/
│   ├── Matrix.cpp
│   └── main.cpp
└── build/

头文件

#ifndef MATRIX_H
#define MATRIX_H
#include <vector>
#include <chrono>

using namespace std;
using namespace chrono;

class Matrix {
public:
    Matrix(int rows, int cols);
    Matrix(const vector<vector<int>>& data);
    int getRows() const;
    int getCols() const;
    int& operator()(int row, int col);
    const int& operator()(int row, int col) const;
    Matrix multiplyNaive(const Matrix& other) const;
    Matrix multiplyOptimized(const Matrix& other) const;
    void print() const;
    vector<vector<int>> getTransposed() const; // 转置辅助
private:
    int rows_;
    int cols_;
    vector<vector<int>> data_;
};
#endif

实现文件

#include "Matrix.h"
#include <iostream>
#include <stdexcept>

Matrix::Matrix(int rows, int cols)
    : rows_(rows), cols_(cols), data_(rows, vector<int>(cols, 0)) {}

Matrix::Matrix(const vector<vector<int>>& data)
    : rows_(data.size()), cols_(data[0].size()), data_(data) {}

int Matrix::getRows() const { return rows_; }
int Matrix::getCols() const { return cols_; }

int& Matrix::operator()(int row, int col) { return data_[row][col]; }
const int& Matrix::operator()(int row, int col) const { return data_[row][col]; }

Matrix Matrix::multiplyNaive(const Matrix& other) const {
    if (cols_ != other.rows_) throw invalid_argument("矩阵尺寸不兼容");
    Matrix result(rows_, other.cols_);
    for (int i = 0; i < rows_; ++i) {
        for (int j = 0; j < other.cols_; ++j) {
            for (int k = 0; k < cols_; ++k) {
                result(i, j) += data_[i][k] * other.data_[k][j];
            }
        }
    }
    return result;
}

Matrix Matrix::multiplyOptimized(const Matrix& other) const {
    if (cols_ != other.rows_) throw invalid_argument("矩阵尺寸不兼容");
    Matrix result(rows_, other.cols_);
    vector<vector<int>> otherTransposed = other.getTransposed();
    for (int i = 0; i < rows_; ++i) {
        for (int j = 0; j < other.cols_; ++j) {
            int sum = 0;
            for (int k = 0; k < cols_; ++k) {
                sum += data_[i][k] * otherTransposed[j][k];
            }
            result(i, j) = sum;
        }
    }
    return result;
}

vector<vector<int>> Matrix::getTransposed() const {
    vector<vector<int>> transposed(cols_, vector<int>(rows_));
    for (int i = 0; i < rows_; ++i) {
        for (int j = 0; j < cols_; ++j) {
            transposed[j][i] = data_[i][j];
        }
    }
    return transposed;
}

void Matrix::print() const {
    for (const auto& row : data_) {
        for (int value : row) cout << value << " ";
        cout << endl;
    }
}

主程序与构建

#include <iostream>
#include <vector>
#include <chrono>
#include "Matrix.h"

using namespace std;
using namespace chrono;

int main() {
    std::cout << "=== 矩阵乘法优化示例 ===" << std::endl;
    const int size = 100;
    Matrix matrix1(size, size);
    Matrix matrix2(size, size);
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            matrix1(i, j) = i + j;
            matrix2(i, j) = i * j;
        }
    }

    auto start = high_resolution_clock::now();
    Matrix resultNaive = matrix1.multiplyNaive(matrix2);
    auto end = high_resolution_clock::now();
    std::cout << "朴素算法耗时：" 
              << duration_cast<milliseconds>(end - start).count() 
              << "毫秒" << std::endl;

    start = high_resolution_clock::now();
    Matrix resultOptimized = matrix1.multiplyOptimized(matrix2);
    end = high_resolution_clock::now();
    std::cout << "优化算法耗时：" 
              << duration_cast<milliseconds>(end - start).count() 
              << "毫秒" << std::endl;
    return 0;
}

构建命令：

mkdir -p build && cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
cmake --build . --config Release
./MatrixMultiplicationOptimization

在100×100的矩阵上，优化版本通常能快一倍以上，数据规模越大差距越明显。

还能做什么

性能优化永无止境。前面这些例子只是入门，如果真遇到瓶颈，可以试试这些方向：

• 用gprof或perf跑一遍你的项目，把热点函数列出来。
• 把智能指针封装成习惯，杜绝裸new/delete。
• 研究一下SIMD指令集，比如SSE或AVX，对循环里密集运算很有帮助。
• 高频分配小对象的场景，可以自己实现内存池。
• 如果是CPU密集型任务，考虑多线程或异步模型，别让核心闲着。