当前位置：首页 > news >正文

office做的网站/免费域名注册二级域名

news 2025/7/2 4:41:53

office做的网站,免费域名注册二级域名,wordpress 插件原理,电商网站建设方案模板目录 C/C内存分布 C语言中的动态内存管理方式 C内存管理方式 new 和 delete 操作内置类型 new 和 delete 操作自定义类型初始化方式 operator new与operator delete函数 new和delete的实现原理内置类型自定义类型 new的原理 delete的原理 new[N] 的原理 delet…

C/C++内存分布

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

C++内存管理方式

new 和 delete 操作内置类型

new 和 delete 操作自定义类型

初始化方式

operator new与operator delete函数

new和delete的实现原理

内置类型

自定义类型

new的原理

delete的原理

new[N] 的原理

delete[N] 的原理

代码实现+图示

new / delete

new[ ] / delete[ ]

使用时进行匹配原因

1.内置类型

2.自定义类型

malloc/free和new/delete的区别

C/C++内存分布

先来了解下C/C++中的内存区域：栈，堆，静态区，常量区，内存映射区。

有些地方叫法可能不同，比如静态区在操作系统中喜欢叫数据段，了解即可。

既然给内存分了这么多区域，肯定有它的用处，不同区域用来存放不同的数据，区域不同，他们的生命周期也会有所不同。下面是对每个区域的解释：

1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。

2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口

创建共享共享内存，做进程间通信。

3. 堆用于程序运行时动态内存分配，堆是可以上增长的。

4. 数据段--存储全局数据和静态数据。

5. 代码段--可执行的代码/只读常量

栈中存放的是函数栈帧创建时创建的一些变量，堆是用来存放动态开辟的一些数据，如C中的malloc等，C++中new出来的对象，都在堆中存放。

下面是一个练习习题，可以用来帮助理解

图解

答案 C C C A A A A A D A B

*char2 是char2 的地址，char2 在栈上创建，所以*char在栈上；

pchar3是函数栈帧内创建的数组，pchar3在栈上，但是 abcd/0在上面已经创建过了，所以会在字符串常量池中，*pchar3的地址指向常量区；

ptr1在栈中创建，ptr1在栈上，但是他的内容是动态开辟出来的，所以*ptr1在堆上。

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

malloc / calloc /realloc / free

这里不过多讲述C语言中的动态内存管理方式

void Test ()
{// 1.malloc/calloc/realloc的区别是什么？int* p2 = (int*)calloc(4, sizeof (int));int* p3 = (int*)realloc(p2, sizeof(int)*10);// 这里需要free(p2)吗？free(p3 );
}

malloc：动态开辟空间

calloc：开辟空间时可以初始化，不过只能初始化为零

realloc：扩容；两种方式：原地扩容和异地扩容；

原地扩容：剩余空间够完成扩容，直接在原地址上增加内存空间。

异地扩容：剩余空间不够完成扩容，会新开辟足够的空间，但是指针指向的地

址会变为新的空间地址

所以上述代码中不需要再 free(p2)。

【面试题】

1. malloc/calloc/realloc 的区别？

2. malloc 的实现原理？ glibc 中 malloc 实现原理

C++内存管理方式

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

new 和 delete 操作内置类型

void Test()
{// 动态申请一个int类型的空间int* ptr4 = new int;// 动态申请一个int类型的空间并初始化为10int* ptr5 = new int(10);// 动态申请10个int类型的空间int* ptr6 = new int[3];delete ptr4;delete ptr5;delete[] ptr6;
}

可以理解为new就是创建，delete就是销毁。

注意：申请和释放单个元素的空间，使用 new 和 delete 操作符，申请和释放连续的空间，使用

new[] 和 delete[] ，注意：匹配起来使用。自定义类型要是不匹配可能会出现错误。

这里给出一种初始化的方法，使用 { }。

int* a1 = new int[10]{1,2,3};// 这里前三个会依次匹配 1  2  3 其余会初始化为 0

new 和 delete 操作自定义类型

new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间

还会调用构造函数和析构函数。

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)); // Cint* p4 = new int;free(p3);delete p4;A* p5 = (A*)malloc(sizeof(A) * 10);A* p6 = new A[10];free(p5);delete[] p6;return 0;
}

class A
{
public:A(int a1 = 0, int a2 = 0): _a1(a1), _a2(a2){cout << "A():" << this << endl;}~A(){cout << "~A():" << this << endl;}
private:int _a1;int _a2;};int main()
{// 这两句的结果相同，但过程不同A* p1 = (A*)malloc(sizeof(A));A* p2 = new A(1, 1);// 目的相同，过程不同。free(p1);delete p2;return 0;
}

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

free 不会，这点也是C++与C的区别。

初始化方式

class A
{
public:A(int a1 = 0, int a2 = 0): _a1(a1), _a2(a2){cout << "A():" << this << endl;}~A(){cout << "~A():" << this << endl;}
private:int _a1;int _a2;};int main()
{// 开辟出十个 A 类型的空间A* p5 = (A*)malloc(sizeof(A) * 10);// 类类型初始化A a1(1), a2(2), a3(3);A* p6 = new A[3]{a1, a2, a3};A a1 = { 1,1 };// 使用{} 这里涉及隐私类型转换A* p6 = new A[10]{ {1,1}, {2,2}, {3,3} };A* p6 = new A[10];free(p5);delete[] p6;return 0;
}

这里记住new和delete要分别调用构造函数和析构函数即可。

new和delete比malloc和free的优点

1.使用比C简单

2.功能跟健全（比如C语言只能初始化为0）

operator new与operator delete函数

new 和 delete 是用户进行 动态内存申请和释放的操作符 ， operator new 和 operator delete 是

系统提供的 全局函数 ， new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

注意：

1. operator new 与 operatro delete 不是对 new 和 delete 的重载。

2. operator new 与 operator delete 是 malloc 和 free 的封装。

3. 可以理解为 new = operator new + 构造； delete = 析构 + operator delete

4. 注意 delete 是先析构再 operator delete

new = operator new + 构造；delete = 析构 + operator

代码 + 图示

class A
{
public:A(int a1 = 0, int a2 = 0): _a1(a1), _a2(a2){cout << "A():" << this << endl;}~A(){cout << "~A():" << this << endl;}
private:int _a1;int _a2;};
int main()
{// 不会调用构造和析构A* p2 = (A*)operator new(sizeof(A));operator delete(p2);// 会调用构造和析构A* p2 = new A(1, 1);delete p2;return 0;
}

图示

下述代码不要求能看懂，注意中文注释即可。

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
失败，尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否
则抛异常。
*/void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{// try to allocate size bytesvoid* p;while ((p = malloc(size)) == 0)if (_callnewh(size) == 0){// report no memory// 如果申请内存失败了，这里会抛出bad_alloc 类型异常static const std::bad_alloc nomem;_RAISE(nomem);}return (p);
}
/*
operator delete: 该函数最终是通过free来释放空间的
*/
void operator delete(void* pUserData)
{_CrtMemBlockHeader* pHead;RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));if (pUserData == NULL)return;_mlock(_HEAP_LOCK); /* block other threads */__TRY/* get a pointer to memory block header */pHead = pHdr(pUserData);/* verify block type */_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));_free_dbg(pUserData, pHead->nBlockUse);__FINALLY_munlock(_HEAP_LOCK); /* release other threads */__END_TRY_FINALLYreturn;
}/*
free的实现
*/#define free(p) _free_dbg(p, _NORMAL_BLOCK)

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc 来申请空间，如果 malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施

就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

C++中的抛异常可以理解为C语言中为了避免错误自己写的判断块，例如 0 不能作为被除数用C++抛异常。

new和delete的实现原理

内置类型

如果申请的是内置类型的空间， new 和 malloc ， delete 和 free 基本类似，不同的地方是：

new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL 。

内置类型使用一般不会出现问题。主要是自定义类型。

自定义类型

上述我们可知C++内存动态管理操作符有 new / delete / new[] / delete[]

new的原理

1. 调用 operator new 函数申请空间

2. 在申请的空间上执行构造函数，完成对象的构造

delete的原理

1. 在空间上执行析构函数，完成对象中资源的清理工作

2. 调用 operator delete 函数释放对象的空间

new[N] 的原理

1. 调用 operator new[ ] 函数，在 operator new[ ] 中实际调用 operator new 函数完成 N 个对

象空间的申请

2. 在申请的空间上执行 N次构造函数

delete[N] 的原理

1. 在释放的对象空间上执行 N 次析构函数，完成 N 个对象中资源的清理

2. 调用 operator delete[ ] 释放空间，实际在 operator delete[ ] 中调用 operator delete 来释

放空间

代码实现+图示

class A
{
public:A(int a1 = 0, int a2 = 0): _a1(a1), _a2(a2){cout << "A():" << this << endl;}~A(){cout << "~A():" << this << endl;}
private:int _a1;int _a2;};
int main()
{//A* p2 = (A*)operator new(sizeof(A));//operator delete(p2);// 核心操作：operator new + 构造函数 A* p2 = new A(1, 1);A* p3 = new A[10];// 核心操作：析构函数 + operator deletedelete p2;delete[] p3;return 0;
}

new / delete

new[ ] / delete[ ]

可以看出此处执行了十次构造和十次析构。

使用时进行匹配原因

这里说的匹配是new 要跟 delete 配合使用，new[ ] 要跟delete[ ]配合使用。

1.内置类型

int main()
{int* a1 = new int[10];delete a1;int* a2 = new int(1);delete[] a2;return 0;
}

这里看出编译器会提醒有问题，但程序照常执行，不会报错

2.自定义类型

class A
{
public:A(int a1 = 0, int a2 = 0): _a1(a1), _a2(a2){cout << "A():" << this << endl;}~A(){cout << "~A():" << this << endl;}
private:int _a1;int _a2;};
int main()
{A* p7 = new A[10];delete p7;    return 0;
}