Welcome to 9ilk's Code World

       

(๑•́ ₃ •̀๑) 个人主页:        9ilk

(๑•́ ₃ •̀๑) 文章专栏：     与C++的邂逅

---

C++中我们总是提到管理资源，资源可以从内存中申请，前提是我们得知道C++对内存管理的布局，本节我们就来学习这块的内容。

---

🏠 C/C++内存分布

我们先来看以下代码：

<code>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";

const 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);

}

对于上述代码中的各个变量它们分别在哪些区域呢？

注：对于char2他是在栈上开5个字节，然后复制在常量区的"abcd"，所以如果问*char2，这里指的是首元素字符'a‘，他就是在栈上。

说明：

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

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

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

堆用于程序运行时动态内存分配，堆是可以上增长的。数据段--存储全局数据和静态数据。代码段--可执行的代码/只读常量。

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

malloc

<code>void* malloc(size_t size);

malloc这个函数功能是向内存(堆区)申请一块指定字节大小连续可用的空间，如果开辟成功，返回一个指向开辟好空间的指针；开辟失败，返回一个NULL指针。

free

void free(void* ptr);

free函数专门用来释放动态开辟的内存，如果参数ptr指向空间不是动态开辟，free函数的行为是未定义的；如果参数是NULL指针，则函数什么事也不做。

calloc

void* calloc(size_t num,size_t size);

calloc函数功能也是用来开辟指定大小的内存空间，如果开辟成功，则返回num个大小为size的连续空间的首地址且空间的每个字节都被初始化为0；如果开辟失败，则返回空指针。

realloc

void* realloc(void* ptr,size_t size);

//ptr是要调整的内存地址

//size是调整好新大小

//返回值为调整之后的内存起始地址

realloc函数可以调整动态开辟好的内存的大小，如果开辟成功则返回调整好之后的内存起始地址，反之开辟失败则返回空。

realloc函数调整动态内存大小的时候会有三种情况：

1. 原有空间之后有足够大空间。此时realloc函数直接在原空间后方进行扩展空间，并返回该内存空间首地址。

2.原有空间之后没有足够大空间。此时realloc函数会在堆区重新找一块合适大小的连续空间使用，把原空间数据拷贝到新空间中，并主动将原空间内存释放，返回新内存空间的起始地址。

3.扩容失败。对于第一第二种情况都没有合适空间，此时就是开辟内存失败，返回NULL。

// 1.malloc/calloc/realloc的区别是什么？

int* p2 = (int*)calloc(4, sizeof (int));

int* p3 = (int*)realloc(p2, sizeof(int)*10);

// 这里需要free(p2)吗？

free(p3 );

对于p3它可能是异地扩充，也可能是原地扩充；如果是原地扩容p2和p3指向同一块空间，free(p3)就能把这块空间释放；如果是异地扩容，此时原空间也就是p2指向空间已经被主动释放归还给操作系统。因此不需要free(p2)了。

🏠 C++中动态内存管理

📌 new/delete操作内置类型

int* p1 = new int;//默认不初始化

int* p2 = new int(10);//但是可以初始化

int *p3 = new int[3];//多个元素也是默认不初始化

int* p4 = new int[3]{1,2}; //剩下的一个元素初始化为0

delete p1;

delete p2;

delete[] p3;

delete[] p4;

说明：

new + 内置类型是动态申请一个内置类型的空间。申请某个内置类型的空间默认不初始化，但可以手动用括号进行初始化。new + 内置类型[size]是申请连续size个内置类型空间。申请连续空间时默认不初始化，但也是可以对指定元素初始化，指定个数小于数组元素个数则剩下初始化为0.释放单个元素的空间时，要用delete操作符释放空间；释放连续空间时，要用delete【】释放。注意不能混着用！

new操作内置类型时，除了用法方便，其他和malloc没什么区别。new主要是给自定义类型设计的。

📌 new/delete操作自定义类型

class A

{

public:

A(int a = 1)

:_a(a)

{

cout << "A()" << endl;

}

~A()

{

cout << "~A()" << endl;

}

private:

int _a;

};

int main()

{

A* pa = (A*)malloc(sizeof(A));

return 0;

}

如果用malloc申请一个自定义类型元素的空间，此时它的成员变量是没有进行初始化的。

A* p2 = new A;

A* p3 = new A(2);

delete p2;

delete p3;

用new申请自定义类型空间时，此时会new完成的任务是申请空间分配地址+调用默认构造函数。当然你也可以显示调用其他构造。而delete完成的任务是先调用析构清理资源，再释放内存空间。

A* p4 = new A[10];//调用10次构造

delete[] p4; //调用10次析构

//自定义类型数组初始化

A aa1(1);

A aa2(2);

A aa3(3);

A* p5 = new A[10]{aa1,aa2,aa3};

delete[] p5;

用new申请自定义类型的一块连续空间时，用法与内置类型一样，不同的是，申请完空间后，会对申请每个对象调用构造；同样的，释放空间需要delete[ ],此时会先调用对象个数次的析构再释放空间。如果对一部分指定初始化，剩下的会调用默认构造。

当然我们可以使用隐式类型转换使初始化变得方便

A* p6 = new A[10]{1,2,3,{6,7}};

//注前面1,2,3是单参数隐式类型转换 {6,7}是多参数隐式类型转换

总结：

1.C++中如果想申请内置类型的对象或数组，用new/delete和malloc/free没什么区别，只不过new/delete更方便些。

2.如果想申请自定义类型的对象或数组，new/delete分别是开空间+构造函数，析构函数+释放空间；malloc和free仅仅是申请空间和释放空间。

3.综上所述，C++中我们建议无论是内置类型还是自定义类型的申请和释放，尽量使用new和delete。

🏠 operator new和operator delete

operator new和operator delete

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

系统提供的全局函数，new在底层调用operator new

全局

函数来申请空间，delete在底层通过operator delete

全局

函数来释放空间。

operator new/operator delete的用法和malloc/free完全一样，都是用来申请和释放空间。

int* p1 = (int*)operator new(sizeof(int)* 10); //申请

operator delete(p1); //销毁

//上面等价于

int* p2 = (int*)malloc(sizeof(int)*10);

free(p2);

实际上operator new也是通过malloc来申请空间，operator delete最终也是通过free来释放空间的。

将malloc封装成operator new主要是为了失败抛异常的机制，如果malloc申请空间成功直接返回，否则执行用户提供的空间不足应对措施；如果用户提供该措施就继续申请，否则抛异常。而operator delete是为了一致性才封装free.

<code>ListNode* n1 = new ListNode(1);

ListNode* n2 = new ListNode(2);

ListNode* n3 = new ListNode(3);

n1->_next = n2;

n2->_next = n3;

在C语言实现链表这个数据结构申请节点时，我们需要判断申请是否成功，需要写if判断malloc返回值，有了new之后，如果失败了它会抛异常，不需要我们检查返回值。

辨析

1.operator new是给对象申请空间的，而构造函数是给对象中成员及其某些指向其他资源的成员初始化的。

2.operator delete是用来释放对象空间的，而析构函数是用来清理某些成员指向的空间资源。

🏠 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出来的，用free释放会发生什么呢?

<code>

class A

{

public:

A(int a = 1)

:_a(a)

{

cout << "A()" << endl;

}

~A()

{

cout << "~A()" << endl;

}

A(const A& aa)

:_a(aa._a)

{

cout << "A(const A & aa) " << endl;

}

private:

int _a;

};

int main()

{

int* p3 = new int[10];

free(p3);

A* p2 = new A[10];

free(p2);

return 0;

}

对于p3，申请内置类型由于new实际是用malloc申请空间，所以用free释放不会有什么问题；但对于p2则会报错。

我们打开监视窗口查看,我们new出来A对象个数应该是10个,为什么申请的是44个字节呢?

其实这多出来的个数是存的对象个数,由于你显示写了析构,编译器会认为你这个析构是需要调用的,因此开头多开空间存了创建对象个数,导致实际空间起始地址发生偏移,而delete和free只会释放原来的起始地址导致报错,delete[ ]则会偏移到正确释放位置.

总结: 不要错配使用,一定要匹配使用,否则结果不确定.

🏠 定位new表达式

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

使用格式

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

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

析构函数是能够显示调用的而构造不行,如果我们想模仿new的行为,此时我们可以使用定位new.

<code>//模拟new

A* p1 = (A*)operator new(sizeof(A));

new(p1)A(10); //对已有空间显示调用构造

//模拟delete

p1->~A();

operator delete(p1);

//模拟new[]

A* p2 = (A*)operator new[](sizeof(A)*10);

for(int i = 0 ; i < 10;++i)

{

new(p2+i)A(i); //用循环更好控制

}

//模拟delete[]

for(int i = 0 ; i < 10;i++)

{

(p2+i)->~A();

}

operator delete[](p2);

使用场景

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

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

🏠 常见面试题

📌 malloc/free和new/delete的区别?

共同点:都是从堆上申请空间，并且需要用户手动释放.

不同点:

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

在释放空间前会调用析构函数完成空间中资源的清理.

---

本节我们认识C++中动态内存管理方式new/delete以及new[ ]/delete[ ],以及他们的实现原理,我们建议在C++中使用他们来申请和释放内存.