深入探索C/C++内存管理

目录

C/C++内存分布

C语言中动态内存管理方式

calloc

realloc

free

C++中动态内存管理方式

  new和delete操作内置类型

  new和delete操作自定义类型

operator new和operator delete函数

new和delete的实现原理

  内置类型

  自定义类型

定位new和表达式(placement-new)

常见面试题

malloc/free和new/delete的区别？

内存泄漏

---

C/C++内存分布

让我们来看看下面这段代码：

int globalVar = 1;
static int staticGlobalVar = 1;

void Test()
{
	static int staticVar = 1;
	int localVar = 1;
	int num1[10] = { 1, 2, 3, 4 };
	char char2[] = "abcd";
	char* pChar3 = "abcd";
	int* ptr1 = (int*)malloc(sizeof (int)* 4);
	int* ptr2 = (int*)calloc(4, sizeof(int));
	int* ptr3 = (int*)realloc(ptr2, sizeof(int)* 4);
	free(ptr1);
	free(ptr3);
}

再看看下面这些选择题：

        知道代码中的各个部分分别存储在内存中的哪一个区域吗？ 

        通过上图你就可以把上面的选择题完成。

说明：

• 栈又叫堆栈，用于存储非静态局部变量/函数参数/返回值等等，栈是向下增长的。
• 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信。
• 堆用于存储运行时动态内存分配，堆是向上增长的。
• 数据段又叫静态区，用于存储全局数据和静态数据。
• 代码段又叫常量区，用于存放可执行的代码和只读常量。

补充：为什么说栈是向下增长的，而堆是向上增长的？

        在一般情况下，在栈区开辟空间，先开辟的空间地址较高，而在堆区开辟空间，先开辟的空间地址较低。（编译器可能存在优化）

#include <iostream>

using namespace std;

int main()
{
	//栈区开辟空间，先开辟的空间地址高
	int a = 10;
	cout << &a << endl;
    int b = 20;
	cout << &b << endl;

	cout << " " << endl;

	//堆区开辟空间，先开辟的空间地址低
	int* c = (int*)malloc(sizeof(int) * 10);
    cout << c << endl;
	int* d = (int*)malloc(sizeof(int) * 10);
	cout << d << endl;

	return 0;
}

注意：

• 栈空间分配：变量a和b作为局部变量存储在栈上，按照栈的“向下增长”规则，先进入栈的变量（a）拥有更高的地址。因此，打印出的&a的值会大于&b的值。
• 堆空间分配：通过malloc函数动态分配的内存位于堆上，传统上认为堆是“向上增长”的，即新分配的内存地址通常会更高。c和d虽然顺序分配，c的地址小于d的地址，但这不保证所有情况下都如此，特别是在存在内存碎片时，新分配的内存地址可能会有所不同。因为在堆区，后开辟的空间也有可能位于前面某一被释放的空间位置。

C语言中动态内存管理方式

malloc

• 功能：malloc 函数用于在内存的堆区域动态地分配一块连续的内存空间。它接收一个参数 size_t size，表示所需分配的内存大小（以字节为单位）。
• 返回值：成功时返回指向分配内存区域的指针，失败时返回 NULL。
• 用法示例：

  int *ptr = (int*)malloc(sizeof(int));

calloc

• 功能：calloc 用于分配一段连续的内存空间，并将这段内存初始化为零。它接收两个参数 size_t num, size_t size，分别表示元素的数量和单个元素的大小（以字节为单位），总共分配 num*size 字节的内存。
• 返回值：同 malloc，成功时返回指向分配内存区域的指针，失败时返回 NULL。
• 用法示例：

  int *ptr = (int*)calloc(10, sizeof(int));

realloc

• 功能：realloc 用于调整之前由 malloc, calloc, 或 realloc 分配的内存块的大小。它接受两个参数：一个指向原内存块的指针和新的大小 size_t size。如果新的大小比原来的内存块大，realloc 可能会移动内存块以满足需求；如果新大小较小，则会释放多余的部分。
• 返回值：成功时返回调整后的内存块地址（可能与原地址不同），失败时返回 NULL，原内存块保持不变。
• 用法示例：

  int *ptr = (int*)malloc(10 * sizeof(int));
  // 后来发现需要更多空间
  ptr = realloc(ptr, 20 * sizeof(int));

free

• 功能：free 用于释放之前通过 malloc, calloc, 或 realloc 分配的内存。它接收一个参数，即指向要释放的内存块的指针。
• 返回值：free 函数没有返回值，因为它是一个操作，而不是查询。
• 用法示例：

  free(ptr);

注意事项：

• 在使用这些函数时，务必确保正确处理分配失败的情况（检查 NULL 返回值）。
• 动态分配的内存不会自动释放，必须显式调用 free 来避免内存泄漏。
• 当重新分配内存后，原始指针可能失效，因此应该使用返回的新指针。

C++中动态内存管理方式

        C语言内存管理的方式在C++中可以继续使用。但有些地方就无能为力而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete 操作符进行动态内存管理。

  new和delete操作内置类型

        1、动态申请单个某类型的空间

int* singleInt = new int; // 申请一个 int 类型的空间

delete singleInt; // 释放内存

等价于：

int* singleInt = (int*)malloc(sizeof(int)); // 申请一个 int 大小的内存

free(singleInt); // 释放内存

        2、动态申请多个某类型的空间

int* manyInts = new int[10]; // 申请10个 int 类型的空间

delete[] manyInts; // 释放内存

等价于：

int* manyInts = (int*)malloc(sizeof(int) * 10); // 申请10个 int 大小的内存

free(manyInts); // 释放内存

        3、动态申请单个某类型的空间并初始化

int* initializedInt = new int(42); // 申请一个 int 类型的空间并初始化为42

delete initializedInt; // 释放内存

等价于：

int* initializedInt = (int*)malloc(sizeof(int)); 
*initializedInt = 42; // 手动初始化

free(initializedInt); // 释放内存

        4、动态申请多个某类型的空间并初始化

int* manyInitializedInts = new int[10]{1, 2, 3, /*...*/, 10}; // 列表初始化前几个元素，其余默认初始化为0

delete[] manyInitializedInts; // 释放内存

等价于

int* manyInitializedInts = (int*)malloc(sizeof(int) * 10);
// 需要手动循环初始化每个元素
for(int i = 0; i < 10; ++i)
    manyInitializedInts[i] = i + 1; // 示例初始化

free(manyInitializedInts); // 释放内存

总结：

• new 和 delete 提供了更高级的内存管理机制，包括类型安全和自动初始化，但可能会有轻微的性能开销。
• malloc 和 free 更接近底层，不执行类型检查，也不提供自动初始化，但在某些特定场景下可能更灵活或效率更高。
• 使用 new/delete 时，对于数组类型的内存，必须使用对应的 new[] 和 delete[]，而 malloc/free 不区分数组和单个对象。

  new和delete操作自定义类型

对于以下自定义类型：

class Test
{
public:
	Test() //构造函数
		:_a(0)
	{
		cout << "构造函数" << endl;
	}
	~Test() //析构函数
	{
		cout << "析构函数" << endl;
	}
private:
	int _a;
};

        1、动态申请单个类的空间 

new/delete 方式：

Test* singleTest = new Test(); // 调用构造函数

delete singleTest; // 调用析构函数，释放内存

malloc/free 方式：

Test* singleTest = (Test*)malloc(sizeof(Test)); // 仅分配内存，不调用构造函数

free(singleTest); // 释放内存，但没有析构函数调用

        2、动态申请多个类的空间

new/delete 方式：

Test* manyTests = new Test[5]; // 分配空间并调用5次构造函数

delete[] manyTests; // 调用5次析构函数，释放内存

malloc/free 方式：

Test* manyTests = (Test*)malloc(sizeof(Test) * 5); // 仅分配内存，不调用构造函数

// 需要手动调用构造函数
for(size_t i = 0; i < 5; ++i)
     new (&manyTests[i]) Test(); // placement new

// 手动调用析构函数
 for(size_t i = 0; i < 5; ++i)
     manyTests[i].~Test();

free(manyTests); // 释放内存，无析构函数调用

总结：

• 使用 new 和 delete（以及 new[] 和 delete[]）操作自定义类型时，会自动调用相应的构造函数和析构函数，这有助于资源管理。
• 而使用 malloc 和 free 时，不会自动调用构造函数和析构函数，需要手动管理对象的生命周期，这在使用自定义类型时容易引发资源泄露或异常行为，因此在现代C++编程中不推荐这样做。
• 对于自定义类型，强烈建议使用 new/delete 或更高级的容器，以充分利用C++的面向对象特性及资源管理机制。

operator new和operator delete函数

        new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

        operator new和operator delete的用法和malloc和free的用法完全一样，其功能都是在堆上申请和释放空间。

        实际上：operator new的底层是通过调用malloc函数来申请空间的，当malloc申请空间成功时直接返回；若申请空间失败，则尝试执行空间不足的应对措施，如果该应对措施用户设置了，则继续申请，否则抛异常。而operator delete的底层是通过调用free函数来释放空间的。

new和delete的实现原理

  内置类型

        如果申请的是内置类型的空间，new/delete和malloc/free基本类似，不同的是，new/delete申请释放的是单个元素的空间，new[ ]/delete [ ]申请释放的是连续的空间，此外，malloc申请失败会返回NULL，而new申请失败会抛异常。 

// 内置类型示例

int* pInt = new int; // 申请单个int空间
delete pInt; // 释放单个int空间

int* pIntArray = new int[5]; // 申请5个int的连续空间
delete[] pIntArray; // 释放5个int的连续空间

  自定义类型

// 自定义类型示例（假设有一个类 MyClass）

class MyClass {
public:
    MyClass() { /* 构造函数 */ }
    ~MyClass() { /* 析构函数 */ }
};

new的原理
1、调用operator new函数申请空间。
2、在申请的空间上执行构造函数，完成对象的构造。

MyClass* pMyClass = new MyClass; // 调用operator new并执行构造函数

delete的原理
1、在空间上执行析构函数，完成对象中资源的清理工作。
2、调用operator delete函数释放对象的空间。

delete pMyClass; // 调用析构函数后，再调用operator delete

new T[N]的原理
1、调用operator new[ ]函数，在operator new[ ]函数中实际调用operator new函数完成N个对象空间的申请。
2、在申请的空间上执行N次构造函数。

MyClass* pMyClassArray = new MyClass[5]; 
// 调用operator new[]，申请5个MyClass对象空间，并执行5次构造函数

delete[ ] 的原理
1、在空间上执行N次析构函数，完成N个对象中资源的清理。
2、调用operator delete[ ]函数，在operator delete[ ]函数中实际调用operator delete函数完成N个对象空间的释放。

delete[] pMyClassArray; 
// 在每个对象上执行析构函数，共5次，然后调用operator delete[]释放空间

定位new和表达式(placement-new)

        定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

使用格式：

new (place_address) type
// 或者
new (place_address) type(initializer-list)

// place_address必须是一个指针，initializer-list是类型的初始化列表

使用场景：

        定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

#include <iostream>

using namespace std;

class A
{
public:
	A(int a = 0) //构造函数 
		:_a(a)
	{
    }

	~A() //析构函数
	{
    }
private:
	int _a;
};

int main()
{
	//new(place_address)type 形式
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A;

	//new(place_address)type(initializer-list) 形式
	A* p2 = (A*)malloc(sizeof(A));
	new(p2)A(2021);

	//析构函数也可以显示调用
	p1->~A();
	p2->~A();

	return 0;
}

注意：在未使用定位new表达式进行显示调用构造函数进行初始化之前，malloc申请的空间还不能算是一个对象，它只不过是与A对象大小相同的一块空间，因为构造函数还没有执行。 

常见面试题

malloc/free和new/delete的区别？

性质和作用域：

• malloc 和 free 是C语言的标准库函数，可以在C和C++中使用。它们属于库层面的内存管理。
• new 和 delete 是C++的运算符，是C++语言的一部分，仅能在C++中使用。它们提供了更高级别的抽象，并且与C++的面向对象特性紧密集成。

构造函数与析构函数：

• 当使用 new 创建对象时，不仅会分配内存，还会自动调用对象的构造函数进行初始化。相应地，delete 会在释放内存之前调用析构函数，以确保对象占用的资源被正确清理。
• malloc 和 free 不具备这种功能，它们只负责分配和释放原始内存块，不会调用构造函数或析构函数。这意味着使用 malloc 分配的内存用来存储类对象时，需要手动调用构造函数和析构函数。

类型安全和自动类型推断：

• new 返回的是指向新分配类型对象的指针，因此它是类型安全的，并且在某些情况下编译器能够自动推断出所需分配的类型大小。
• malloc 返回的是 void* 指针，需要类型转换才能正确使用，增加了出错的可能性。

异常处理：

• 如果 new 无法分配足够的内存，它会抛出 std::bad_alloc 异常（可以通过异常处理机制捕获）。这使得内存分配失败的处理更加灵活和安全。
• malloc 在内存不足时则返回 NULL，需要程序员检查返回值并作出相应处理，否则可能导致程序崩溃。

重载与覆盖：

• new 和 delete 是操作符，可以被重载，允许程序员自定义内存分配和释放的行为。
• malloc 和 free 是函数，虽然在C++中可以被覆盖，但通常不建议这样做，因为它们是全局作用域的函数，覆盖可能会影响整个程序的内存管理行为。

内存初始化：

• new 可以通过 new T() 形式分配并默认初始化对象，或者使用 new T{args} 进行值初始化。而对于数组，new T[n] 会默认初始化所有元素。
• malloc 分配的内存不会被初始化，保留原有内容，这在某些场景下可能需要额外的清零或其他初始化步骤。

 简短总结一下就是：

共同点：

1. 都是从堆上申请空间，并且需要用户手动释放。

不同点：

1. malloc和free是函数，new和delete是操作符。
2. malloc申请的空间不会初始化，new申请的空间会初始化。
3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可。
4. malloc的返回值是void*，在使用时必须强转，new不需要，因为new后跟的是空间的类型。
5. malloc申请失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常。
6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数和析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理。

内存泄漏

概念：内存泄漏是指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;

	// 2.异常安全问题
	int* p3 = new int[10];
	Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
	delete[] p3;
}

内存泄漏分类

1、堆内存泄漏(Heap leak)
        堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

2、系统资源泄漏
        指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如何避免内存泄漏？ 

1、工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记住匹配的去释放。
2、采用RAII思想或者智能指针来管理资源。
3、有些公司内部规范使用内部实现的私有内存管理库，该库自带内存泄漏检测的功能选项。
4、出问题了使用内存泄漏工具检测。

总结： 内存泄漏非常常见，解决方案分为两种：
 1、事前预防型。如智能指针等。
 2、事后查错型。如泄漏检测工具。