菏泽市网站建设_网站建设公司_GitHub_seo优化

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

void test1() { int* p1 = (int*)malloc(sizeof(int)); free(p1); // 1.malloc/calloc/realloc的区别： // malloc - 只分配内存，不初始化 // calloc - 分配内存并初始化为0，参数是(元素个数, 每个元素大小) // realloc - 重新分配内存，可以扩大或缩小已有内存块 int* p2 = (int*)calloc(4, sizeof(int)); // 分配4个int并初始化为0 int* p3 = (int*)realloc(p2, sizeof(int) * 10); // 将p2的内存扩大到10个int // 这里不需要free(p2)！ // 因为realloc成功后，原来的p2指向的内存已经被释放或移动 // 如果realloc返回新指针，原指针p2不应该再被使用 free(p3); // 只需要释放新的指针p3 }

malloc是分配内存，不会初始化

calloc是分配内存初始化为0，参数（元素个数，每个元素的大小）

realloc是重新分配内存，可以扩大或者缩小已有的内存

在C++中兼容我们的C语言，所以C语言的动态内存管理在C++也可以使用

学习C++中的动态内存管理的方法

C语言内存管理方式在C++中可以继续使用，但是有一些地方不一定能做到，并且使用起来会有一些麻烦，因此，C++引出了自己的内存管理方式：通过new和delete操作符进行动态内存管理

但是，我们需要注意的是，malloc/free是库函数，而new/delete是操作符

void test1() { //C语言 malloc等是库函数 int* p1 = (int*)malloc(sizeof(int)); free(p1); //C++ new/delete是操作符 // 动态申请一个int类型的空间 int* ptr4 = new int;//写法 // 动态申请一个int类型的空间并初始化为10 int* ptr5 = new int(10);//写法 delete ptr4; delete ptr5; }

那么，new/delete和malloc/free有没有什么区别呢？

如果动态申请的对象是内置类型，那么用malloc和new没有什么区别，如果动态申请的对象是自定义类型，那么就有区别，比如

class A { public: A(int a=0) :_a(a) { cout<<"A()"<<endl; } ~A() { cout<<"~A()"<<endl; } private: int _a; }; int main() { //C语言自定义类型开辟空间 A* p3 = (A*)malloc(sizeof(A));//没有初始化 free(p3); //C++自定义类型开辟空间 A* p4 = new A;//调用构造函数初始化 delete p4;//调用析构函数 }

new和delete不仅仅会开空间和释放空间，还会调用构造函数和析构函数

接下来我们用数据去看，malloc和new的区别：

我们使用malloc没有初始化

使用了new进行了初始化

那我们想给new的对象传参应该怎么写呢？

A* p4 = new A(10);//调用构造函数初始化 //我们也可以new数组： A *ptr1 = new A[10];//new了10个对象，调用了10次构造函数 delete[] ptr1;

需要注意的是：在new数组的时候，delete需要+[]

总结：

对于内置类型用malloc和new没有什么区别，但是使用自定义类型就有区别，用malloc和new的区别是：new和delete会去调用构造函数和析构含糊，一定要匹配的去使用，不然会造成崩溃，在C++中，也建议去使用new和delete，malloc和free能做到的，那么new和delete也能做到，相反，new和delete能做到的，malloc和free不一定能够做到

operator new 与 operator delete函数

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

注意：operator new 与 operator delete函数是全局的库函数，他们并不是new和delete的重载

我们使用new一个新对象T的时候，编译器有两个做法

1、申请内存，调用operator new(底层其实是将malloc封装)

2、调用库函数

在delete的时候，编译器会发生

1、调用T的析构函数

2、调用operator delete(底层其实是将free封装)

我们平时写malloc，会这样子去写

int main() { //malloc失败，返回NULL char* p1 = (char*)malloc((size_t)2*1024*1024*1024); if(p1==NULL) { printf("malloc fail\n"); } else { printf("malloc success\n"); } return 0; }

那么new操作符在new失败的时候会怎么去处理呢？

int main() { char* p2 = new char[0x7fffffff]; //并没有执行 if(p2==NULL) { printf("new fail\n"); } else { printf("new success\n"); } return 0; }

可以看到，new失败的时候，并没有去执行if语句

我们说过，malloc和new不一样，new在申请空间失败的时候，会抛出异常，下面我们看一段抛出异常的代码

int main() { try { void* p1 = new char[1024 * 1024 * 1024]; cout << p1 << endl; void* p2 = new char[1024 * 1024 * 1024]; cout << p2 << endl; void* p3 = new char[1024 * 1024 * 1024]; cout << p3 << endl; } catch (const exception& e) { cout << e.what() << endl;//抛出异常 } return 0; }

operator new其实就是对malloc的封装，如果申请内存失败了，抛出异常，封装malloc+抛出异常

operator delete也是对free进行封装

通过上述两个全局函数的例子

我们可以发现

operator new实际也是通过mallloc来申请空间，如果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来释放空间

int main() { Stack st; Stack* ps = new Stack; delete ps; retunr 0; }

定位new表达式(placement-new)

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

使用格式：

new (place_address) type或者new（place——address）type（initializer-list）

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

构造函数调用什么时候自动调用呢？

1、创建对象时

2、new一个对象时

class A { private: int _a; public: A(int a = 0)//构造函数 :_a(a) { cout << _a << "：" << "A(int a = 0)构造函数" << endl; } ~A()//析构函数 { cout << _a << "：" << "~A()析构函数" << endl; } }; int main() { A* ptr1 = (A*)malloc(sizeof(A)); //显示调用构造函数用来初始化一块已经开辟好的空间 new(ptr1)A(10); //显示调用析构函数 ptr1->~A(); //释放ptr1指向的空间 free(ptr1); A* ptr2 = (A*)operator new(sizeof(A)); //显示调用构造函数用来初始化一块已经开辟好的空间 new(ptr2)A; //显示调用析构函数 ptr2->~A(); //释放ptr2指向的空间 operator delete(ptr2); return 0; }

ptr1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行，显式对一块空间调用构造函数初始化，new(ptr1) A;

如果我们复制一份a数组到另外一块空间b数组，怎么复制呢？

也许你想的是这样，通过一个循环来拷贝：

int main() { A a[5]; //复制一份a数组到另外一块空间b A* pb1 = new A[5]; for(int i =0;i<5;++i) { b[i]=a[i]; } cout<<endl; //代价大 构造+赋值 return 0; }

但是这样代价大，经过了构造+赋值重载，那么能不能直接构造呢？通过定位new表达式就可以直接构造：

int main() { A a[5]; //能不能直接构造？ A *pb = (A*)malloc(sizeof(A)*5); for(int i =0;i<5;++i) { new(pb+i)A(a[i]); }//只有构造 return 0; }

常见面试题

malloc/free和new/delete的区别
1、特点和用法

malloc和free是函数，new和delete是操作符；malloc申请空间时，需要手动计算空间大小并传递，new只需在后面跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可；malloc的返回值是void*，在使用时需要强转，new不需要，因为new后面跟的是空间的类型

2、底层原理区别

申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数和析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

3、处理错误的方式

malloc申请空间失败时，返回NULL，因为使用时需要判空，new不需要，但是new需要捕获异常

内存泄漏
什么是内存泄漏呢？
在堆上申请了的空间，在我们不用了以后也没有释放，就存在内存泄漏，因为你不用了，也没有还给系统，别人也用不了。俗话说：占着茅坑不拉屎

那么我们如何预防内存泄漏呢？

1、智能指针

2、内存泄漏的检测工具