C/C++内存管理

本文介绍: 详解C/C++内存管理，对动态空间深入进行说明，另外也补充了析构和构造函数的调用

一，C/C++内存分布

5，malloc/free和new/delete的区别

三，动态空间的析构和构造

一，C/C++内存分布

内存区域的大概介绍：

C/C++中，我们目前需要了解的内存区域是栈区、堆区、静态区、常量区。其中，栈区用于临时存储数据，如函数的栈帧，局部变量等。堆区一般用来存储动态开辟的空间，如malloc、c alloc、re alloc、new等开辟的空间。静态区原名是代码段，一般存储全局变量和静态数据，在整个程序都可以使用。常量区用来存储常量，如字面量等。这些东西之前有过说明，这里我们简单提一下即可。

以上东西全为基础，接下来我们来看看以下代码中的数据的存储空间。

int globalVar = 1;
static int staticGlob alVar = 1;
void Tes t()
{
   static int staticVar = 1;
   in t localVar = 1;
   i n t num1[10] = { 1, 2, 3, 4 };
   char char2[] = “abc d“;
   const char* pCh ar3 = “abc d“;
   i n t* ptr1 = (int*)malloc(sizeof(int) * 4);
   int* ptr2 = (int*)c alloc(4, sizeof(int));
   int* ptr3 = (int*)re alloc(ptr2, sizeof(int) * 4);
   free(ptr1);
   f r ee(ptr3);
}
选项 : A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在 C staticGlob alVar在 C
staticVar在 C localVar在 A
num1 在 A

char2在 A * char2在 A
pCha r3在 A    * pCha r3在 D
ptr1在 A    * p tr1在 B

分析：前5个好理解，要注意的是后面六个选项。char2在函数栈帧中创建了一个数组，其代表了首元素的地址，存储在栈区中，而*char2代表首元素，也存储在栈区中。pCh a r3要注意的是，这里的const 修饰的是*pCh a r3，即 “abc d” 是一个字面量，存储在常量区中，而pChar3是一个指针，存储在栈区中。ptr1的类型是int* ，指向堆区中开辟动态空间的首地址，因此，ptr1存储在栈区中，*ptr1指向数据，存储在堆区中。

二，C++动态开辟空间

1，new/delete 操作 内置 类型

我们都知道，C语言中有malloc、c alloc、re alloc、free 语法进行动态空间的管理，而C++中通过 new和delete 操作符进行动态空间管理。其中new用来开辟空间，delete用来释放空间。其中，new 可以对创建的空间进行初始化。

//动态开辟一个int型的空间
int* p1 = new int;//里面是随机值，不会初始化
int* p2 = new int(1);//动态开辟一个空间并初始化为1

//动态开辟多个int型的空间
int* p3 = ne w int[5]{ 1, 2 };//动态开辟5个空间并初始化为1 2 0 0 0
int* p4 = ne w int[10];//里面是随机值，不会初始化

//删除开辟一个空间
delete p1;
delete p2;

//删除开辟多个空间
delete[] p3;
delete[] p4;

注意：C++中de let e在释放中不支持一次多次释放，如下：

//下面是错误的用法

d e let e p1,p2;

d e let e[] p3,p4;

new 操作符在没有指定初始化的时候系统不会自动初始化。

#include <iostream>
#include <string>
using namespace std;
int main()
{
   int n = 2;
   int* a = new int[n];
   a[0] = 0;
   a[1] = 1;
   a = new int[2 * n];//重新分配空间大小，里面全部是随机值
   return 0;
}

2，new和delete操作 自定义 类型

这里要说明的是，操作自定义时，new/delete 和 malloc/free的最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数进行空间的初始化和释放。

class A
{
public:
   A(int a = 0)
       : _a(a)
   {
       cout << “A():” << thi s << endl;
   }

   ~A()
   {
       cout << “~A():” << thi s << endl;
   }

private:
   int _a;
};

int main()
{
   //通过调试可见，动态开辟空间初始化过程中调用了构造函数
   //只调用一次构造函数
   A* p1 = new A;
   A* p2 = new A(1);
   A aa1(1);
   A aa2(1);
   A aa3(1);
   //调用了三次构造函数
   A* p3 = new A[3]{ aa1, aa2, aa3 };
   A* p4 = new A[3]{A(2), A(2), A(2) };
   A* p5 = new A[3]{ 3, 3, 3 };

   //通过调试可见，动态空间释放过程中调用了析构函数
   //只调用一次析构函数
   delete p1;
   delete p2;
   //调用了三次析构函数
   delete[] p3;
   delete[] p4;
   delete[] p5;
   return 0;
}

总的来说：

new的本质：开空间+调用构造函数初始化。

delete的本质：调用析构函数释放空间。

通过以上可总结出，在开辟和释放的过程中，new关键字开辟了多少个动态类型空间，将会调用多少次构造函数；delete关键字释放了多少个动态类型空间，将会调用多少次析构函数。其中new开辟的空间无论是否进行初始化，构造函数都会被调用。

3，new/delete底层 实现

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

o perator new 和operator delete函数：

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

op erator delete: 该函数结构复杂，最终是通过free来释放空间。

底层函数的调用：

当系统底层调用op erator new和op erator delete函数进行申请空间或释放空间时，无论开辟/释放一个空间或多个空间时，对应的函数只调用一次，即一次性直接分配或释放足够的内存空间。

op erator new和op erator delete函数是通过C语言中的malloc和f ree来实现的，因此，两函数的调用方法也跟malloc/f ree一样。

Stack* p2 = (Stack*)operator new(sizeof(Stack)); //如同Stack* p2 = new Stack
operator delete(p2); //如同delete p2

new的空间扩展：

当使用new开辟多个内存空间时，其实还在这块空间的前面多开辟了四个字节的空间，用来存储开辟类型空间的数量，当delete内部实现到free时也会将其释放。

c las s Sta ck //一个栈类
{
public:
   Sta ck(int capacity = 4)
   {
       cout << “Sta ck(int capacity = 4)” << endl;

       _a = new int[capacity];
       _top = 0;
       _capacity = capacity;
   }
   ~Sta ck()
   {
       cout << “~Sta c k()” << endl;

       delete[] _a;
       _a = nullptr;
       _top = 0;
       _capacity = 0;
   }
private:
   int* _a;
   int _top;
   int _capacity;
};

int main()
{
   Sta ck* p3 = new Stack[10];
   int* p = (int*)p3 – 1;
   cout << *p << endl; //输出10，记录了连续存储的10个Stack

delete[] p3
   return 0;
}

下面要说明的是，new/delete new[]/delete[] m alloc/free一定要配对使用，否则结果将会是未定义，有时可能会出现系统崩溃，因此当系统释放空间时，可能会导致释放空间的位置不正确，具体如何释放取决于编译器的优化程度。这里我们了解即可。

4，new和delete的实现 原理

内置类型：

当申请内置类型的空间时，new和mall oc，delete和free基本类似，不同的地方是： new在申请空间失败时会抛异常，mall oc会返回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来释
    放空间

5，mall oc/free和new/delete的区别

共同点：

1，malloc/free和new/delete都是从堆上动态申请不定量的空间，并且手动释放。

不同的点：

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

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

3，malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可。

4，malloc的返回值为vo id*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型。
5，malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是 new需要捕获异常。

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

三，动态空间的析构和构造

这里要说明的是：构造函数可以手动调用，但析构函数不可以手动调用。

clas s A
{
public:
   A(int a = 0)
       : _a(a)
   {
       cout << “A():” << this << endl;
   }
   ~A()
   {
       cout << “~A():” << this << endl;
   }
private:
   int _a;
};
int main()
{
   A* p1 = (A*)operator new(sizeof(A));

    A a(5);
   //不能调用构造函数
   //p1->A(1);

//a->A(5);
   //可以调用析构函数
   p1->~A();
   a.~A();
   return 0;
}