【C++】内存管理和内存优化

最新推荐文章于 2025-03-06 15:41:47 发布

Guiat

最新推荐文章于 2025-03-06 15:41:47 发布

阅读量1.1k

点赞数 22

CC 4.0 BY-SA版权

分类专栏： C++ 文章标签： c++

本文链接：https://blog.youkuaiyun.com/Go_ahead1025/article/details/143473820

C++ 专栏收录该内容

18 篇文章

订阅专栏

在这里插入图片描述

上期回顾: 【C++】构造函数、拷贝构造函数、析构函数、内联函数
个人主页：C_GUIQU
归属专栏：C++

在这里插入图片描述

正文

1. C++内存管理概述

1.1 内存布局

在C++程序运行时，内存主要分为以下几个区域：

代码区：存放程序的可执行代码，通常是只读的，多个进程可以共享这部分内存。
全局/静态存储区：用于存储全局变量和静态变量。这些变量在程序的整个生命周期内都存在，并且在程序启动时就被分配内存。
栈区：由编译器自动管理分配和释放。用于存储局部变量、函数参数等。栈的内存分配是按照后进先出（LIFO）的原则进行的，当一个函数被调用时，它的局部变量和参数会被压入栈中，函数返回时，这些内存会被自动释放。
堆区：这是程序员手动管理分配和释放的内存区域。通过使用new（C++ 11之前常用）或malloc（C风格函数，在C++中也可使用，但不推荐作为首选）等操作符来申请堆内存，使用delete（对应new）或free（对应malloc）来释放堆内存。

1.2 内存管理的重要性

有效的内存管理对于C++程序至关重要，原因如下：

资源利用：合理管理内存可以确保程序不会浪费宝贵的系统内存资源，使得程序能够在有限的内存环境下稳定运行，特别是在资源受限的设备上，如嵌入式系统。
性能提升：正确的内存分配和释放策略可以减少内存碎片，提高内存访问速度，从而提升程序的整体性能。
避免内存错误：不当的内存管理可能导致诸如内存泄漏（申请的内存未释放，导致内存占用不断增加）、悬空指针（指向已释放内存的指针）、越界访问（访问超出所分配内存范围的区域）等严重错误，这些错误可能导致程序崩溃、数据损坏甚至安全漏洞。

2. C++内存管理基础：动态内存分配与释放

2.1 使用`new`和`delete`进行内存管理

2.1.1 分配单个对象

#include <iostream>

int main() {
    // 使用new分配一个整数类型的内存空间
    int* ptr = new int;
    // 对分配的内存进行赋值
    *ptr = 42;
    std::cout << "The value stored in the allocated memory: " << *ptr << std::endl;
    // 使用delete释放内存
    delete ptr;
    return 0;
}

在上述代码中：

首先通过new int动态地在堆上分配了足够存储一个int类型数据的内存空间，并返回指向该内存的指针ptr。
然后将值42赋给了通过指针ptr所指向的内存位置。
最后通过delete ptr释放了之前通过new分配的内存，以避免内存泄漏。

2.1.2 分配数组

#include <iostream>

int main() {
    // 使用new分配一个包含5个整数的数组内存空间
    int* arrPtr = new int[5];
    for (int i = 0; i < 5; ++i) {
        arrPtr[i] = i * 10;
    }
    // 输出数组元素
    for (int i = 0; i < 5; ++i) {
        std::cout << arrPtr[i] << " ";
    }
    std::cout << std::endl;
    // 使用delete[]释放数组内存
    delete[] arrPtr;
    return 0;
}

这里：

通过new int[5]在堆上分配了能够存储5个int类型数据的连续内存空间，返回的指针arrPtr指向数组的首元素。
接着使用循环对数组元素进行赋值。
最后通过delete[] arrPtr正确地释放了分配给数组的内存。注意，对于通过new[]分配的数组内存，必须使用delete[]来释放，否则会导致内存泄漏和未定义行为。

2.2 使用`malloc`和`free`进行内存管理（不推荐但需了解）

虽然在C++中更提倡使用new和delete进行内存管理，但malloc和free作为C语言遗留下来的函数在C++中也可以使用。

#include <iostream>
#include <cstdlib>

int main() {
    // 使用malloc分配一个整数类型的内存空间
    int* ptr = (int*)malloc(sizeof(int));
    if (ptr!= NULL) {
        // 对分配的内存进行赋值
        *ptr = 42;
        std::cout << "The value stored in the allocated memory: " << *ptr << std::endl;
        // 使用free释放内存
        free(ptr);
    } else {
        std::cout << "Memory allocation failed." << std::endl;
    }
    return 0;
}

在这个示例中：

首先通过malloc(sizeof(int))在堆上分配了足够存储一个int类型数据的内存空间，返回的指针需要进行强制类型转换为int*类型（因为malloc返回的是void*类型指针）。
然后在确保分配成功（指针不为NULL）的情况下对内存进行赋值操作。
最后通过free(ptr)释放了之前通过malloc分配的内存。

需要注意的是，malloc和free与new和delete有以下几点区别：

new和delete是C++的运算符，除了分配和释放内存外，还会调用对象的构造函数和析构函数（对于类类型对象），而malloc和free只是单纯的内存分配和释放函数，不会涉及对象的构造和析析构操作。
new和delete的语法更加简洁和面向对象，在分配和释放数组时也有专门的语法（new[]和delete[]），而malloc和free在处理数组时需要手动计算数组的大小并进行相应的操作。

3. 内存泄漏及其防范

3.1 什么是内存泄漏

内存泄漏是指程序在动态分配内存后，由于某种原因（如忘记释放、丢失了指向已分配内存的指针等），导致这些内存无法被回收利用，使得程序占用的内存随着时间的推移不断增加，最终可能耗尽系统的可用内存。

例如：

#include <iostream>

void memoryLeakFunction() {
    // 分配内存但不释放
    int* ptr = new int;
    *ptr = 10;
    // 这里没有对ptr进行delete操作
}

int main() {
    memoryLeakFunction();
    // 程序继续运行，但是之前在memoryLeakFunction中分配的内存已经泄漏
    return 0;
}

在上述代码中，memoryLeakFunction函数内部通过new分配了一块内存给int类型的变量，但在函数结束时没有使用delete释放这块内存，导致内存泄漏。

3.2 防范内存泄漏的方法

3.2.1遵循内存管理规则

始终确保对于每一次通过new分配的内存，都有相应的delete操作来释放它（对于数组则使用delete[]）。可以采用一些编程规范，如在代码的同一位置（比如函数的开头或结尾）进行内存的在分配和释放操作，以便于跟踪和管理。

3.2.2 使用智能指针

C++ 11引入了智能指针（std::shared_ptr、std::unique_ptr等）来自动管理对象的生命周期，从而有效避免内存泄漏。智能指针会在对象不再被引用时自动释放其所指向的内存。

#include <iostream>
#include <memory>

void noMemoryLeakFunction() {
    // 使用std::unique_ptr来自动管理内存
    std::unique_ptr<int> ptr = std::make_unique<int>();
    *ptr = 10;
    // 当函数结束时，如所期望的那样，std::unique_ptr会自动释放所指向的内存
}

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

在这个示例中，通过使用std::unique_ptr，不需要手动进行内存释放操作，当noMemoryLeakFunction函数结束时，std::unique_ptr会自动释放它所指向的内存，从而避免了内存泄漏。

3.2.3 内存泄漏检测工具

可以利用一些专门的内存泄漏检测工具，如Valgrind（在Linux环境下）等，来帮助检测程序中是否存在内存泄漏以及确定泄漏的位置。这些工具通过分析程序的运行时内存使用情况来找出潜在的内存泄漏问题。

4. 悬空指针及其处理

4.1 什么是悬空指针

悬空指针是指一个指针曾经指向一块有效的内存区域，但后来这块内存被释放了，而指针仍然存在且没有被设置为NULL或重新指向其他有效内存区域，这样的指针就称为悬空指针。

例如：

#include <iostream>

int main() {
    int* ptr = new int;
    *ptr = 20;
    // 释放内存
    delete ptr;
    // 此时ptr成为悬空指针，因为它指向的内存已经被释放
    // 如果在这里再次使用ptr，比如*ptr = 30;，将会导致未定义行为
    return 0;
}

在上述代码中，先通过new分配了一块内存给ptr指向的int类型变量，然后使用delete释放了这块内存，此时ptr就变成了悬空指针。如果后续不小心再次使用ptr进行赋值等操作，就会引发未定义行为，可能导致程序崩溃、数据错误等严重后果。

4.2 处理悬空指针的方法

4.2.1 设置指针为NULL

在释放内存后，立即将指针设置为NULL，这样在后续使用指针时，可以通过检查指针是否为NULL来判断它是否有效。

#include <iostream>

int main() {
    int* ptr = new int;
    *ptr = 20;
    // 释放内存
    delete ptr;
    // 将指针设置为NULL
    ptr = NULL;
    // 现在如果不小心再次使用ptr，比如*ptr = 30;，就可以通过检查ptr是否为NULL来避免未定义行为
    return 0;
}

4.2.2 使用智能指针

同样，智能指针（如std::shared_ptr、std::unique_ptr）不仅可以防止内存泄漏，也可以有效避免产生悬空指针。当智能指针所指向的内存被释放时，智能指针自身会进行相应的处理，不会让用户接触到悬空指针的情况。

5. 内存优化策略

5.1 减少不必要的内存分配

5.1.1 对象复用

在程序中，如果有多个地方需要使用类似的对象，可以考虑复用已创建的对象，而不是每次都重新分配内存创建新的对象。
例如，假设有一个函数需要频繁使用一个特定大小的数组：

#include <iostream>

// 全局数组，可供复用
int globalArray[10];

void functionThatUsesArray() {
    // 直接使用全局数组，而不是每次都重新分配内存创建新的数组
    for (int i = 0; i < 10; ++i) {
        globalArray[i] = i * 2;
    }
    // 输出数组元素
    for (int i = 0; i < 10; ++i) {
        std:// 这里应该是笔误，可能是想写std::cout << globalArray[i] << " ";
        cout << globalArray[i] << " ";
    }
    std::cout << endl;
}

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

在这个示例中，通过使用全局数组globalArray，避免了在functionThatUsesArray函数每次执行时都重新分配内存创建新的数组，从而节省了内存分配和释放的开销。

5.1.2 缓存结果

对于一些计算密集型的函数，如果其输入参数相对固定，那么可以考虑缓存其计算结果，以便下次遇到相同输入参数时直接使用缓存结果，而不需要再次进行计算和相应的内存分配。
例如，假设有一个函数计算斐波那契数列：

#include <iostream>

// 用于缓存斐波那契数列结果的数组
int fibonacciCache[100];

int fibonacci(int n) {
    if (n == 0 || n == 1) {
        return n;
    }
    // 先检查缓存中是否已有结果
    if (fibonacciCache[n]!= 0) {
        return fibonacciCache[n];
    }
    // 如果缓存中没有结果，则进行计算
    fibonacciCache[n] = fibonacci(n - 1) + fibonacci(n - 2);
    return fibonacciCache[n];
}

int main() {
    // 计算斐波那契数列第10项
    int result = fibonacci(10);
    std::cout << "The 10th Fibonacci number: " << result << std::endl;
    return 0;
}

在这个示例中，通过设置fibonacciCache数组来缓存斐波那契数列的 = “”">的计算结果，当再次计算相同项数的斐波那契数列时，就可以直接从缓存中获取结果，避免了重复的内存分配和计算操作。

5.2 优化内存布局

5.2.1 结构体对齐

在定义结构体时，编译器会按照一定的规则对结构体中的成员进行对齐，以提高内存访问速度。但是，有时候这种对齐方式可能会导致额外的内存浪费。可以通过调整结构体成员的顺序来优化内存布局，减少不必要的内存空间占用。
例如，假设有以下结构体：

#include <iostream>

// 原始结构体
struct OriginalStruct {
    char c;
    int i;
};

// 优化后的结构体
struct OptimizedStruct {
    int i;
    char c;
};

int main() {
    // 计算原始结构体的大小
    std::cout << "Size of OriginalStruct: " << sizeof(OriginalStruct) << std::endl;
    // 计算优化后的结构体的大小
    std::cout << "Size of OptimizedStruct: " << sizeof(OptimizedStruct) << std::endl;
    return 0;
}

在上述示例中，对于OriginalStruct结构体，由于编译器会对int类型成员进行对齐，所以即使char类型成员只占1个字节，整个结构体的大小也会是8个字节（在常见的332位系统下）。而对于OptimizedStruct结构体，将int类型成员放在前面，char类型成员放在后面，优化后的结构体大小为5个字节，从而减少了内存浪费。

5.2.2 数组连续存储

如果程序中有多个数组需要频繁交互数据，尽量将它们存储在连续的内存空间中，这样可以提高数据访问速度，减少因内存分散导致的性能损失。

5.3 减少内存碎片

5.3.1 内存池技术

内存池是一种预先分配一定数量的内存块，然后在程序需要时从内存池中获取内存块，使用完毕后再将内存块归还到内存池的技术。通过使用内存池，可以减少因频繁的动态内存分配和释放导致的内存碎片问题。
例如，假设有一个简单的内存池实现：

#include <iostream>
#include <vector>

// 内存池类
class MemoryPool {
public:
    MemoryPool(size_t poolSize) : pool(poolSize) {}

    // 从内存池获取一块内存
    void* getMemoryBlock() {
        if (pool.empty()) {
            return NULL;
        }
        void* block = pool.back();
        pool.pop_back();
        return block;
    }

    // 将内存块归还到内存池
    void returnMemoryBlock(void* block) {
        pool.push_back(block);
    }

private:
    std::vector<void*> pool;
};

// 示例结构体，用于在内存池中分配内存来存储该结构体实例
struct MyData {
    int value;
    // 可以添加更多成员变量来模拟更复杂的数据结构
};

int main() {
    // 创建一个大小为10的内存池
    MemoryPool myPool(10);

    // 从内存池获取一块内存用于存储MyData结构体实例
    void* block1 = myPool.getMemoryBlock();
    MyData* data1 = new (block1) MyData;
    data1->value = 42;

    // 输出通过内存池分配内存存储的数据值
    std::cout << "Value of data1 from memory pool: " << data1->value << std::endl;

    // 从内存池获取另一块内存
    void* block2 = myPool.getMemoryBlock();
    MyData* data2 = new (block2) MyData;
    data2->value = 100;

    std::cout << "Value of data2 from memory pool: " << data2->value << std::endl;

    // 使用完毕后，将内存块归还到内存池
    myPool.returnMemoryBlock(block1);
    myPool.returnMemoryBlock(block2);

    // 以下是关于中韩合作成果相关内容的示例输出，这里只是简单展示如何结合代码示例进行内容输出
    std::cout << "\n中韩合作成果展示：" << std::endl;
    std::cout << "在经济领域，双方的贸易往来日益频繁，投资合作不断深化，推动了两国经济的发展。" << std::endl;
    std::cout << "在文化领域，中韩两国的文化交流活动丰富多彩，增进了两国人民之间的相互了解和友谊。" << std::endl;
    std::cout << "在科技领域，双方也开展了不少合作项目，促进了科技成果的转化和应用。" << std::endl;

    return 0;
}