C++内存管理方式

new/delete操作内置类型

new/delete操作自定义类型

C++保留malloc和free的原因

new、delete和malloc、free的区别

new、delete底层实现

new的三种使用方式

C++内存管理方式

C语言中内存管理几个常用函数是malloc、calloc、realloc和free。它们是用来在堆上开辟销毁空间的。C++作为C语言的发展，也支持malloc等这些函数，但是因为malloc、free是函数不是运算符，不在编译器控制权限之内，不能将调用构造、析构函数的任务强加给它们，因此，C++需要一个能同时完成动态内存分配和初始化工作的运算符new，以及完成清理与释放内存工作的运算符delete。

new/delete操作内置类型

在对内置类型的操作上，new/delete 与 malloc/free 几乎没有区别，只是new的写法较之malloc要简单许多：

int main()
{int* a = new int;delete a;return 0;
}

但是注意：C++的运算符new不会自动初始化：

因此要初始化需要手动添加内容：

动态开辟数组：

同样不会初始化，也需要手动，用{ }

相比于malloc，又要计算开辟字节大小，又要强制类型转化，new还是比较方便的。

new/delete操作自定义类型

对于内置类型，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* d = new A(1);delete d;return 0;
}

有一点一定要注意：new和delete，malloc和free，一定要匹配！！不要互相之间混用。

还有new [ ]、delete [ ] ，new、delete也要匹配！！不要出现申请数组，释放却只释放第一个指针的情况，这样很容易出问题。

以上面的A类为例，看看不匹配会怎么样

int main()
{A* d = new A[10];delete d;return 0;
}

我们发现，这里只调用了一次析构函数并报错了。

但是有的编译器可能不会报错，可这不意味着我们可以不匹配，这容易造成严重问题。

以VS2013平台为例说明一下为什么会报错（不同编译器不一样，这里仅是作为参考）

开辟10个A类型对象的同时也会调用10次构造函数，那么在delete释放空间的时候编译器怎么知道我们开辟了多大的空间呢，怎么知道要调用多少次析构函数呢？（如果new和delete代码相隔很远，编译器不可能通过上下文知道）

在构造的时候，编译器会在数组头部记录下大小，也就是说如果new了10个字节空间，可能编译器开了11个，头部一个用来记录大小，delete的时候连同头部的；一起释放。

如果不delete [ ] ，而是只delete，那么编译器默认以为你开辟的是单个空间，而不是数组，那头部必然不会存大小，因此在头部后面位置释放空间，释放位置错误也就崩溃了。

同样的，new 和 delete[ ] 也不能这样匹配，同样会引发问题，最好配对使用。

还有的情况不会报错，比如将析构函数屏蔽，也就是让编译器自己实现析构函数。

这是因为delete的时候没有显示写的析构函数，编译器默认自己生成，类里是内置类型析构没有什么可清理的东西，编译器就进行优化不在头部存数组大小，因此delete释放位置就没有向后偏移，完成了清理释放。

同理，如果将delete改为free释放也不会报错，因为free不会调用析构函数。但是尽量做到匹配，new对应delete，malloc对应free，不要混用！

C++保留malloc和free的原因

如此看来new和delete完全可以取代malloc和free啊，为什么C++没有这么做呢？

1、C++程序经常要调用C函数，C程序只能用malloc和free来管理动态内存，并且有些C++底层可能是用malloc和free来实现new和delete的。

2、在某些情况下，malloc和free效率高于new和delete，因此某些STL实现版本的内存分配器会采用malloc和free来进行存储管理。

new、delete和malloc、free的区别

1. malloc和free是函数，new和delete是操作符

2. malloc申请的空间不会初始化，new可以初始化

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

4、new和delete更加安全，new可以自动计算要构造对象的字节数量，而malloc则要自己设置字节数。new直接返回目标类型指针，不需要显示转换，而malloc返回void*，必须显示转换成目标类型才能使用。

5、我们可以自己重载new、delete，实现富有个性的内存分配和释放，而malloc和free不能重载。

6、malloc失败返回空指针，new失败抛异常

malloc失败返回空指针，new失败抛异常。

1、malloc失败返回空指针

int main()
{while (1){int* a = (int*)malloc(sizeof(int)*1024*1024*100);if (a){cout << a << endl;}else{cout << "malloc fail" << endl;break;}}return 0;
}

2、new失败抛异常

int main()
{try{while (1){int* a = new int[1024*1024];cout << a << endl;}}catch (exception& e){cout << e.what() << endl;}return 0;
}

bad allocation说明开辟失败。

new、delete底层实现

上面说 “C++保留malloc和free的原因” 时提到了new底层是malloc实现的，delete底层是free实现的，那么具体是什么情况呢？

new是由全局函数operator new 和构造函数实现的，operator new又是由malloc实现的，注意：这里operator new不是运算符重载，而是全局函数！这个命名比较容易产生误会。

同样，delete是全局函数operator delete和析构函数实现的，Operator delete又是free实现的。

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

operator new底层实现：

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底层实现：

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;
}

new的三种使用方式

一、plain new

也就是普通的new，即我们上面说的new，遵循一般规则。

二、nothrow new（很不常见）

不抛异常的new，在失败时返回空指针，使用它时不需要设置异常处理，和malloc一样检查返回值是否为空即可。

三、placement new（定位new）

允许在一块已经开辟内存的空间上构造对象或对象数组，并且它不会分配内存失败（因为它根本就不分配内存，而是只调用对象的构造函数初始化）。

placement new的主要用途是在一块频繁使用的内存上进行构造初始化。

这也与池化技术联系到了一起。

当我们需要频繁开辟一块内存时，我们可以提前开好一块较大的内存，在上面进行构造初始化，类似内存池。

先开好池（大块内存），再将河水（数据）送往池中，需要的时候在池中取水即可，不一定非得每次去河边打水。

对于每次从内存池来的数据，placement new就对其初始化，这就是它的用处。

在一块已经申请好的较大的内存上，使用placement new可以在上面构造不同类型的对象或者它们的数组。比如你可以先申请一块足够大的字符数组，然后用placement new在上面int类型对象或者double类型数组。

也可以这样使用placement new创建数组。

    //申请10个testClass类大小的动态内存char *buff=new char[sizeof(testClass)*10];memset(buff,0,sizeof(buff));//将buff的首地址赋值给一个testClass类testClass* start=(testClass*)buff;//循环for(int i=0;i<10;++i){new (start+i)testClass(i);  //placement new一个testClass对象std::cout<<"class"<<i+1<<":"<<(start+i)->getData()<<std::endl;(start+i)->~testClass();   //使用完之后释放对象（但是动态内存仍存在）}//最后是释放动态内存delete [] buff;

需要注意的是，对于自定义类型，用placement new构造起来的对象或者数组，要显示地调用它们的析构函数（析构函数不释放对象的内存，内存依然在那里，可供后面构造的对象或数组使用），千万不能在这时候delete，因为placement new构造起来的对象或数组大小不一定等于原来分配的内存大小，因此使用delete会造成内存泄漏或在后面释放时出错。要在不再使用这块内存时，显示调用析构函数销毁对象后再delete释放空间。