C/C++内存管管理

C/C++的内存分布

C/C++中通常认为内存分为堆区，栈区，内存映射段，静态区（数据段），常量区（代码段）。

• 全局变量，静态变量存在静态区（数据段）中。
• 局部变量，形式参数等存在栈区。
• 动态申请释放的空间在堆区。
• 常量字符串等存在常量区。

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";
//字符数组存在栈区，“abcd”常量字符串在常量区
const char* pChar3 = "abcd";
//pChar3局部变量在栈区，“abcd”常量字符串在常量区
int* ptr1 = (int*)malloc(sizeof(int) * 4);
int* ptr2 = (int*)calloc(4, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
//ptr1，ptr2，ptr3都是局部变量在栈区，其指向的空间在堆区
free(ptr1);
free(ptr3);
}

C中动态内存管理

• malloc
  
  参数是想要开辟内存空间的大小（字节），返回值是void* 根据需要进行强制类型转换。
  所开辟的空间不进行初始化。
• calloc
  
  两个参数，作用是开辟几个每个所需要的空间是多少（字节）
  所开辟的空间被初始化为0。
  例如：

int* a = (int*)calloc(10,sizeof(int));

realloc

对ptr所指向的空间进行调整，可以扩容可以缩容，但一般用来扩容使用，若第一个参数是空指针，那么它的作用等同于malloc
扩容

• 原地扩容：若当前空间后面仍有大量空间可供扩容使用，那么就会原地扩容。
• 异地扩容：若当前空间后面没有足够空间供扩容使用，那么系统会重新找一块足够大的空间，将原空间的数据拷贝到新空间，并且将原空间释放。
  free
  
  释放在堆区动态开辟的空间

思考题：
4. malloc/calloc/realloc的区别？

malloc和calloc是从堆区上申请空间，realloc是对原空间的大小进行调整。
realloc第一个参数为NULL时，相当于malloc。
malloc申请空间不初始化，calloc申请空间并初始化。
realloc在扩容时存在原地扩容和异地扩容的问题。

C++中动态内存管理

C中的动态内存管理函数，已经不能完全满足C++的需要，所以C++中出现了新的动态内存管理的方式：new 和 delete操作符进行动态内存管理。

new delete操作内置类型

• new

int* p1 = new int;
int* p2 = new int[10];

可以看到用new操作符进行动态资源的申请是很方便的，不用强制类型转换，也不需要计算要开辟空间的大小，还有一点就是不需要在申请后检查是否开辟成功。
malloc申请空间失败后返回空指针，所以在使用malloc申请资源后要进行检查，而new 操作符开辟失败后是采用抛异常的方式，不需要检查。

另外，new在申请空间的同时，可以对其进行初始化：

int *p1 = new int(6);
int* p2 = new int[6]{1,2,3,4,5,6};

• delete
  delete释放new出来的空间，且要配套使用，delete对应new delete[ ]对应new [ ]，如果不配套使用可能会出现问题（后面会提到）。

int* p1 = new int[6];
delete p1;

这样就会出错的。

new delete操作自定义类型

class A
{
public:
    A(int a = 0,int b = 0)
        :_a(a)
        ,_b(b)
    {
        cout << "A()" << endl;
    }
    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a;
    int _b;
};
int main()
{
    A* p = (A*)malloc(sizeof(A));
    if (p == NULL)
    {
        perror("malloc fail\n");
        exit(-1);
    }
    free(p);
    A* ptr = new A;
    delete ptr;
    return 0;
}

可以看到malloc和free并不会调用自定义类型的构造和析构函数。

new 和 delete 调用了自定义类型的构造和析构函数。

所以new 和 delete 是为了自定义类型而生的，对于内置类型与malloc和free没有什么区别（只是使用上的区别），但是对于自定义类型来说，new会调用构造函数，delete会调用析构函数。

构造函数不能显示调用（可以用定位new调用）
析构函数可以显示调用

operator new 与 operator delete 函数

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

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
失败，尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否
则抛异常。
*/
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
	// try to allocate size bytes
	void *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 new 是全局函数，是对malloc的封装，申请失败就不会在返回空指针，而是抛异常。

/*
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_FINALLY
return;
}

operator delete也是全局函数，是对free的封装。

new 和 delete实现原理

• new
  1，调用operator new申请空间
  2，调用构造函数
• new [ ]
  1，调用opeartor new[ ]函数，就是调用多次operator new函数，申请多个空间
  2，调用多次构造函数
• delete
  1，在申请的空间上调用析构函数，完成对对象的清理。
  2，调用operator delete函数释放申请的空间
• delete[ ]
  1，在申请的空间上调用多次析构函数，完成对对象的清理。
  2，调用operator delete [ ]，就是调用operator delete 函数来释放空间。

为什么说new delete new[] delete[] malloc free 要配套使用，下面的例子足以证明：
讲一下，new[ ],和delete[ ]是如何实现的？

int* p1 = new int[6];

[6]就会告诉编译器，要申请6个int大小的空间，并完成6次构造函数的调用。

delete[] p1;

delete[ ]并没有写明释放几个对象的空间，调用几次析构函数，他是如何完成的呢？
实际上new [ ]的时候编译器会做一些小操作，让其多开辟4个字节的空间，存放开辟几个对象的空间以让delete [ ]使用。

如果此时你用delete或者是free来释放此段空间会报错，因为不允许从中间部分来释放动态开辟的空间。并为只会调用一次析构，不能对所有对象完成清理工作。

class A
{
public:
    A(int a = 0,int b = 0)
        :_a(a)
        ,_b(b)
    {
        cout << "A()" << endl;
    }
    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a;
    int _b;
};
int main()
{
    A* ptr1 = new A[6];
    delete ptr1;
    return 0;
}

定位new的使用

上面提到malloc操作自定义类型时，不会调用构造函数，采用定位new 的方式能够显示调用构造函数。

class A
{
public:
    A(int a = 0,int b = 0)
        :_a(a)
        ,_b(b)
    {
        cout << "A()" << endl;
    }
    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a;
    int _b;
};
int main()
{
    A* ptr = (A*)operator new(sizeof(A));
    new(ptr)A(2, 3);
    return 0;
}

定位new后

这里只是为了举例，定位new通常是配合内存池使用的。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。