C/C++内存管理

目录

C/C++内存分布

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

malloc的实现原理

C++内存管理方式

new/delete操作内置类型

new和delete操作自定义类型

​  

operator new与operator delete函数

new和delete的实现原理

内置类型

自定义类型

定位new

malloc/free和new/delete的区别

 内存泄漏（浅谈）

---

C/C++内存分布

注意：

 arr2是数组，在栈上，“aaa”是常量字符串，在代码段，parr是指针，在栈上，*parr是解引用，为“a”，在代码段。

C++内存区域划分图可能因操作系统和编译器而有所不同。上述示意图只是一个概念性展示，并不能完整地反映实际情况。

• 内核空间：操作系统使用的专用内存区域，其中运行着操作系统的核心功能。

• 栈：用于保存函数调用信息和局部变量等。它从高地址向低地址增长，并且由编译器自动管理。

• 堆：用于手动分配和释放动态内存。它从低地址向高地址增长，并且需要开发人员负责管理。

• 内存映射段：用于映射共享库、动态链接器以及其他需要与进程共享的文件。这些文件通常是可执行代码或者资源文件，它们通过内存映射技术加载到进程的地址空间中供使用。

• BSS段：用于存放未初始化的全局变量和静态变量。在程序启动时，这些变量会被自动初始化为零或空值。

• 数据段：包含已初始化和未初始化的全局变量以及静态变量。它在程序加载时分配内存。

• 代码段：包含可执行指令/只读常量。它通常是只读的，并且存放着程序的机器指令。

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

malloc、calloc和realloc是在C/C++中用于动态内存分配的函数。它们之间的区别如下：

• malloc： malloc(size_t size) 函数用于分配指定大小的内存块，并返回一个指向该内存块起始地址的指针。被分配的内存块中的初始值是不确定的，需要手动进行初始化。

• calloc： calloc(size_t num, size_t size) 函数用于分配一片连续空间，可以容纳num个大小为size字节的元素，并将这片空间初始化为0。相比于malloc，calloc会自动清零所分配到的内存。

• realloc： realloc(void* ptr, size_t new_size) 函数用来重新调整先前通过 malloc 或 calloc 分配过得已经释放或者尚未释放（传入ptr） 的堆空间大小，扩大或缩小后返回新地址。如果扩大后可能导致原有数据丢失或者发生截断，则会创建一个新区域并将原有数据复制到其中。

总结：

• malloc只负责申请指定大小但未初始化内容；
• calloc与malloc类似，在申请之外还会把申请到得所有字节都置为0；
• realloc则是对先前申请到得堆进行重新调整以满足需求。

malloc的实现原理

malloc函数的实现原理是由操作系统提供的。

当调用malloc(size_t size)时，操作系统会在进程的堆上分配一块指定大小（size）的内存空间。具体步骤如下：

1. 首先，检查堆是否有足够大且连续的空闲内存来容纳请求的大小。
2. 如果有足够大的连续空闲内存，则将该部分标记为已使用，并返回一个指向该内存块起始地址的指针。
3. 如果没有足够大且连续空闲内存，则进行动态扩展堆大小：
   • 操作系统会尝试从物理内存中获取更多可用空间或者通过合并相邻未使用区域来获得更大连续空间。
   • 如果成功获取到足够大且连续的内存块，则将其标记为已使用，并返回一个指向该新分配内存块起始地址的指针。
4. 返回给用户申请到的有效地址。

需要注意以下几点：

• malloc只负责分配虚拟地址，并不保证物理上是连续分布。因此，在使用过程中不能假设所申请到得各个字节之间是相邻或者线性排列着；
• 调用完malloc后返回值需校验是否为空，以防止发生内存分配失败的情况；
• 用户不应该依赖于malloc返回的地址进行越界访问或者释放未分配内存等操作，这可能导致程序崩溃或者出现其他错误。

C++内存管理方式
 

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

new/delete操作内置类型

#include<iostream>
using namespace std;
int main()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;
	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
	// 动态申请10个int类型的空间
	int* ptr6 = new int[10];
	delete ptr4;
	delete ptr5;
	delete[] ptr6;
	return 0;
}
//int main()

 注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用
new[]和delete[]，注意：匹配起来使用。

new和delete操作自定义类型

#include<iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	// new/delete 和 malloc/free最大区别是 new/delete对于自定义类型除了开空间
	//还会调用构造函数和析构函数
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;
	// 内置类型是几乎是一样的
	int* p3 = (int*)malloc(sizeof(int)); // C
	int* p4 = new int;
	free(p3);
	delete p4;
	cout << endl;
	cout << endl;
	A* p5 = (A*)malloc(sizeof(A) * 3);
	A* p6 = new A[3];
	free(p5);
	delete[] p6;
	return 0;
}

 注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。 

operator new与operator delete函数

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

operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

new和delete的实现原理

对内置类型和自定义类型分别解释。 

内置类型

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

自定义类型

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

delete的原理:
        1. 在空间上执行析构函数，完成对象中资源的清理工作
        2. 调用operator delete函数释放对象的空间
new T[N]的原理
        1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对
        象空间的申请
        2. 在申请的空间上执行N次构造函数
delete[]的原理
        1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
        2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释
        放空间

定位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)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	free(p1);
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}

malloc/free和new/delete的区别
 

`malloc()` 和 `free()` 是C语言中用于动态内存分配和释放的函数，而 `new` 和 `delete` 是C++中对应功能的操作符。

以下是它们之间的主要区别：

1. 语法差异：
   - 在C中，使用 `malloc()` 分配内存，返回一个指向void类型的指针。需要手动计算所需内存大小，并进行强制类型转换。
   - 在C++中，使用 `new` 运算符来分配内存，并自动根据数据类型确定所需空间大小。返回一个指向正确数据类型的指针。

2. 构造函数调用：
   - 使用 `malloc()` 分配内存时，并不会调用对象构造函数。因此，在处理类对象时需要单独调用构造函数初始化相关成员变量。
   - 使用 `new` 运算符分配内存时，会自动调用相应类的构造函数来初始化对象。

3. 扩展性：
   - C++ 的操作符可以重载（overload），允许用户定义各种形式、参数个数和特定行为的版本。
   - C 中没有这样的机制。虽然可以创建一些库或封装以提供类似重载功能，但在语言层面上并不支持。

4. 内部实现细节：
   - `malloc()` 和 `free()` 是由操作系统提供并实现于标准库中。
     在底层通常利用了堆内存管理算法来分配和释放内存。
   - `new` 和 `delete` 是C++编译器的关键字，它们会调用底层的运行时库函数（如`operator new()` 和 `operator delete()`）来执行实际的内存分配和释放操作。

总之，使用C语言时应该使用 `malloc()` 和 `free()` 来进行动态内存分配和释放。而在C++中，则更推荐使用 `new` 和 `delete` 运算符，因为它们提供了更直观、类型安全且方便的方式来处理动态内存管理，并能够正确地调用构造函数和析构函数。

 内存泄漏（浅谈）

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

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

#include<iostream>
using namespace std;
void main()
{
	// 内存申请了忘记释放
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A;
}