内存管理——关于malloc/free与new/delete

     内存分配方式有三种：

（1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。

（2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。

（3）从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。

C语言中使用malloc/calloc/realloc/free进行动态内存管理，malloc/calloc/realloc用来在堆上开辟空间，free将申请的空间释放掉。

1.【堆中】
void TestMemory ()
{// malloc
     int * pTest = ( int*) malloc(10 * sizeof( int));
     DoSomething();
     if ( pTest != NULL)
    {
        free( pTest);
        pTest = NULL;
    }// calloc 该函数会将申请的内存空间初始化为0
int * pTest1 = ( int*) calloc(10, sizeof( int));
DoSomething();
if ( pTest != NULL)
{
   free( pTest);
   pTest = NULL;
}
// realloc，改变原有内存空间大小，若不能改变，则将会开辟一段新的内存，
//将原有内存的内容拷贝过去，
// 但不会对新开辟的空间进行初始化
   int * pTest2 = ( int*) malloc(10 * sizeof( int));
   realloc( pTest2, 100*sizeof( int));
   free( pTest2);
}
注意：堆上的内存需要用户自己来管理，动态malloc/calloc/realloc的空间，必须free掉，否则会造成内存泄露；栈上空间具有函数作用域，在函数结束后系统自动回收，不用用户管理。
2、【栈中】
使用_alloc在栈上动态开辟内存，栈上开辟的内存由编译器自动维护，不需要用户显式释放。
常见的内存泄漏问题：

void MemoryLeaks()
{
// 1、内存申请了忘记释放
int *pTest = (int *)malloc(10*sizeof( int));
assert(NULL != pTest);
DoSomething();
// 2、程序逻辑不清，以为释放了，实际内存泄露
int *pTest1 = (int *)malloc(10*sizeof( int));
int *pTest2 = (int *)malloc(10*sizeof( int));
DoSomething();
pTest1 = pTest2;
free(pTest1);
free(pTest2);
// 3、程序误操作，将堆破坏
char *pTest3 = (char *)malloc(5);
strcpy(pTest3, "Memory Leaks!");
free(pTest3);
// 4、释放时传入的地址和申请时的地方不相同
int *pTest4 = (int *)malloc(10*sizeof( int));
assert(NULL != pTest4);
pTest4[0] = 0;
pTest4++;
DoSomething();
free(pTest4);
}

C++中通过new和delete进行动态内存管理。

有了malloc/free为什么还要new/delete呢？

malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。对于非内部数据类型的对象而言，光用malloc/free无法满足动态对象的要求。对象在创建的同时自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制范围内，不能够把执行构造函数和析构函数的任务强加于它们。因此C++需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。



new和delete、new[]和delete[]一定匹配使用，一定匹配使用，一定匹配使用！！！

重要的事说三遍！否则可能出现内存泄露甚至崩溃的问题。

new和delete的功能完全覆盖了malloc和free，C++之所以还保留malloc和free，是因为C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。

【malloc/free和new/delete的区别和联系】

1. 它们都是动态管理内存的入口。

2. malloc/free是C/C++标准库的函数，new/delete是C++操作符。

3. malloc/free只是动态分配内存空间/释放空间。而new/delete除了分配空间还会调用构造函数和析构函数进行初始化与清理（清理成员）。

4. malloc/free需要手动计算类型大小且返回值会void*，new/delete可自己计算类型的大小，返回对应类型的指针。

#include <iostream>
#include <stdlib.h>
#include <malloc.h>
using namespace std;

class Array
{
public :
Array (size_t size = 10): _size(size ), _a(0)
{
cout<<"Array(size_t size)" <<endl;
if (_size > 0)
{
_a = new int[ size];
}
}
~ Array()
{
cout<<"~Array()" <<endl;
if (_a )
{
delete[] _a ;
_a = 0;
_size = 0;
}
}
private :
int*_a ;
size_t _size ;
};
void Test ()
{
Array* p1 = (Array*) malloc(sizeof (Array));
Array* p2 = new Array;
Array* p3 = new Array(20);
Array* p4 = new Array[10];
free(p1);
delete p2 ;
delete p3 ;
delete[] p4 ;
}

int main()
{
Test();

system("pause");
return 0;}

运行结果：



C++的其他内存管理接口（placement版本）
void * operator new (size_t size);
void operator delete (size_t size);
void * operator new [](size_t size);
void operator delete[] (size_t size);
总结:
1. operator new/operator delete operator new[]/operator delete[] 和 malloc/free用法一样。
2. 他们只负责分配空间/释放空间，不会调用对象构造函数/析构函数来初始化/清理对象。
3. 实际operator new和operator delete只是malloc和free的一层封装。
【new作用】
调用operator new分配空间。

调用构造函数初始化对象。
【delete作用】
调用析构函数清理对象
调用operator delete释放空间

【new[]作用】
调用operator new分配空间。

调用N次构造函数分别初始化每个对象。

【delete[]作用】
调用N次析构函数清理对象。

调用operator delete释放空间。