C++性能调优与内存调试完全指南

1
2
3
4
5
void memoryLeak() {
    int *ptr = new int[100];  // 申请内存
    // 忘记删除或异常退出
    // delete[] ptr;  // 缺少这一行
}  // 内存泄漏！

1
2
3
4
5
6
7
8
9
10
int* danglingPointer() {
    int *ptr = new int(42);
    delete ptr;
    return ptr;  // 返回悬垂指针
}

void use() {
    int *p = danglingPointer();
    *p = 100;  // 未定义行为！
}

1
2
3
4
void bufferOverflow() {
    char buffer[10];
    strcpy(buffer, "This is a very long string!");  // 溢出！
}

1
2
3
4
5
void doubleFree() {
    int *ptr = new int(42);
    delete ptr;
    delete ptr;  // 重复释放！
}

1
2
3
4
void uninitializedMemory() {
    int *ptr = new int;  // 未初始化
    printf("%d\n", *ptr);  // 读取未定义的值
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// leak_example.cpp
#include <iostream>
#include <vector>

class Resource {
public:
    Resource(int id) : id_(id) {
        std::cout << "Resource " << id_ << " created\n";
    }
    ~Resource() {
        std::cout << "Resource " << id_ << " destroyed\n";
    }
private:
    int id_;
};

void leakFunction() {
    Resource *res = new Resource(1);
    int *arr = new int[100];
    // 忘记释放
}

int main() {
    for (int i = 0; i < 5; i++) {
        leakFunction();
    }
    std::cout << "Program ending\n";
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
// heap_overflow.cpp
#include <iostream>
#include <cstring>

int main() {
    char *buffer = new char[10];
    strcpy(buffer, "This is a very long string!");  // 溢出！
    std::cout << buffer << std::endl;
    delete[] buffer;
    return 0;
}

1
2
3
4
5
6
7
8
9
// use_after_free.cpp
#include <iostream>

int main() {
    int *ptr = new int(42);
    delete ptr;
    std::cout << *ptr << std::endl;  // 使用后释放！
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// memory_leak.cpp
#include <iostream>
#include <vector>

void leakMemory() {
    int *ptr = new int[100];
    // 没有delete
}

int main() {
    for (int i = 0; i < 1000; i++) {
        leakMemory();
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// valgrind_test.cpp
#include <iostream>
#include <cstring>

void stackOverflow() {
    int arr[10];
    arr[20] = 100;  // 栈溢出
}

void heapLeak() {
    int *ptr = new int(42);
    // 未释放
}

void useAfterFree() {
    int *ptr = new int(42);
    delete ptr;
    std::cout << *ptr << std::endl;
}

int main(int argc, char *argv[]) {
    if (argc > 1) {
        int choice = argv[1][0] - '0';
        if (choice == 1) stackOverflow();
        if (choice == 2) heapLeak();
        if (choice == 3) useAfterFree();
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
void problematicFunction() {
    int *ptr = new int[100];      // 分配400字节（100*4)
    char *str = new char[50];     // 分配50字节
    // 缺少delete语句
}

int main() {
    for (int i = 0; i < 10; i++) {
        problematicFunction();    // 调用10次
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 情形A：直接泄漏
void directLeak() {
    int *ptr = new int(42);
    // delete ptr;  // 未释放 → definitely lost
}

// 情形B：间接泄漏
struct Node {
    Node *next;
    int value;
};

void indirectLeak() {
    Node *head = new Node{nullptr, 1};
    head->next = new Node{nullptr, 2};
    // delete head;  // 只删除了head，head->next丢失 → indirectly lost
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// performance_test.cpp
#include <iostream>
#include <algorithm>
#include <cstring>

const int LARGE_SIZE = 10000000;

void inefficientSort() {
    int *arr = new int[LARGE_SIZE];
    for (int i = 0; i < LARGE_SIZE; i++) {
        arr[i] = rand() % 1000;
    }
    
    // 使用低效的排序
    for (int i = 0; i < LARGE_SIZE; i++) {
        for (int j = i + 1; j < LARGE_SIZE; j++) {
            if (arr[i] > arr[j]) {
                std::swap(arr[i], arr[j]);
            }
        }
    }
    
    delete[] arr;
}

void efficientSort() {
    int *arr = new int[LARGE_SIZE];
    for (int i = 0; i < LARGE_SIZE; i++) {
        arr[i] = rand() % 1000;
    }
    
    // 使用STL排序（O(n log n)）
    std::sort(arr, arr + LARGE_SIZE);
    
    delete[] arr;
}

int main() {
    std::cout << "Starting performance test...\n";
    inefficientSort();  // 这个会很慢
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
// 不推荐
void unsafeCode() {
    int *ptr = new int(42);
    // ... 可能出异常
    delete ptr;  // 可能不会执行
}

// 推荐：使用RAII和智能指针
void safeCode() {
    std::unique_ptr<int> ptr(new int(42));
    // 自动释放，异常安全
}

1
2
3
4
5
6
7
8
9
10
11
12
// 不推荐：频繁重分配
std::vector<int> vec;
for (int i = 0; i < 1000000; i++) {
    vec.push_back(i);  // 可能导致多次重分配
}

// 推荐：预分配
std::vector<int> vec;
vec.reserve(1000000);  // 一次分配足够的内存
for (int i = 0; i < 1000000; i++) {
    vec.push_back(i);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class ObjectPool {
    std::vector<std::unique_ptr<int>> available_;
    std::vector<std::unique_ptr<int>> inUse_;
    
public:
    int* acquire() {
        if (!available_.empty()) {
            auto obj = std::move(available_.back());
            available_.pop_back();
            int *ptr = obj.get();
            inUse_.push_back(std::move(obj));
            return ptr;
        }
        auto obj = std::make_unique<int>();
        int *ptr = obj.get();
        inUse_.push_back(std::move(obj));
        return ptr;
    }
    
    void release(int *ptr) {
        for (auto it = inUse_.begin(); it != inUse_.end(); ++it) {
            if (it->get() == ptr) {
                available_.push_back(std::move(*it));
                inUse_.erase(it);
                break;
            }
        }
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 不友好的分支
int *data = new int[256];
std::sort(data, data + 256);
for (int i = 0; i < 256; i++) {
    if (data[i] >= 128)  // 分支不可预测
        sum += data[i];
}

// 友好的分支
int *data = new int[256];
std::sort(data, data + 256);
for (int i = 0; i < 256; i++) {
    sum += data[i] * (data[i] >= 128);  // 分支消除
}

1
2
3
4
5
6
7
8
9
10
11
12
13
// 行为：跳跃式访问，缓存错误
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        sum += matrix[j][i];  // 列式访问
    }
}

// 改进：顺序访问
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        sum += matrix[i][j];  // 行式访问
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
// 普通循环
for (int i = 0; i < n; i++) {
    result[i] = a[i] + b[i];
}

// SIMD优化（编译器自动向量化）
// 加 -march=native -O3 标志
for (int i = 0; i < n; i += 4) {
    _mm128 va = _mm_loadu_ps(&a[i]);
    _mm128 vb = _mm_loadu_ps(&b[i]);
    _mm128 vr = _mm_add_ps(va, vb);
    _mm_storeu_ps(&result[i], vr);
}