C/C++内存管理之new与delete的使用及原理解析

一、C/C++中程序内存区域划分

内存区域相关作用：

• 栈又叫堆栈:非静态局部变量、函数参数、返回值等等，栈是向下增长的
• 内存映射段时高效的I/O映射方式，用于装载一个共享的动态内存库，用户可以使用系统接口创建共享共享内存，做进程间通信
• 堆用于程序运行时动态内存分配，堆时可以上增长的
• 数据段:存储全局数据和静态数据
• 代码段:可执行的代码、只读常量

在语法上将数据段称为静态区、代码段称为常量区，而以上操作系统的命名。

提出相关思考:

• 为什么要分不同的区域
• 哪个区域是我们需要重点关注的

回答:

• 根据对象不同的生命周期和作用域，分配到不同的区域中，统一管理，高效地对对象进行处理
• 堆是我们要需要重点关注的，这是系统留给我们控制的内存，其他系统是自动的

1.1 相关练习测试

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";
    const char* pChar3 = "abcd";
    int* ptr1 = (int*)malloc(sizeof(int) * 4);
    int* ptr2 = (int*)calloc(4, sizeof(int));
    int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
    free(ptr1);
    free(ptr3);
}

答案:

• 选择题:C、C、C、A、A 。A、A、A、D、A、B
• 填空题：40、5、4、4/8、4、4/8

这里容易混洗的char str1[] ="abcd"与const char* str2 ="abcd"。这里str1是个数组将常量拷贝到数组，而str2是直接指向常量区中常量。

二、C语言中动态内存管理方式

C语言中，系统通过一系列函数赋予了我们对堆上空间的控制

void Test ()
{
int* p1 = (int*) malloc(sizeof(int));
free(p1);
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
free(p3 );
}

提出思考:

• malloc/calloc/realloc的区别是什么？
• 这里使用realloc是否还需要free(p2)
• malloc的实现原理?

第一个问题的回答:

对于malloc/calloc/realloc是系统为我们提供在堆上申请空间的途径。在功能上大体是相同的，对于malloc与calloc这两个函数，除了参数部分及其是否完成初始化，其他功能是相同的。

relloc比较特别，属于扩容时使用的函数。扩容有两种方式：原地扩容和异地扩容。如果realloc第一个参数部分为空，可以当作malloc使用)。具体还是参考下这篇博客有详细解释内存管理

第二个问题的回答:

由于realloc进行了扩容操作。如果是原地扩容，在原来开辟空间上完成扩容操作，这里p3会同p2指向这块空间，只需要free(p3)；如果是异地扩容，将p2空间中数据拷贝一份，在堆上找一块空间充足地方，完成扩容和拷贝操作，p2指向原空间，会被系统自动收回，不需要对p2进行free操作。对此无论是原地还是异地，只需要free(p3)即可

第三个问题的回答:

可以通过该链接进行学习GLibc堆利用入门

三、C++内存管理方式

在C++中，虽然可以继续使用C语言对于内存管理方式，但是在有些地方就无能为力，而且使用起来比较麻烦。对此因此C++又提出了自己的内存管理方式:通过new和delete操作符进行动态内存管理

3.1 使用new/delete进行数据操作

3.1.1 new/delete 操作内置类型

int main()
{
	//动态申请一个int类型的空间
	int* ptr1 = new int;
	//动态申请一个int类型的空间并且初始化为10
	int* ptr2 = new int(10);
	//动态申请10个int类型的空间
	int* ptr3 = new int[3];
	//动态申请10个int类型的空间并且完成初始化
	int* ptr4 = new int[10]{ 1,2,3 };//剩下没有明确给值，默认为0
	delete ptr1;
	delete ptr2;
	delete []ptr3;
	delete[]ptr4;
	return 0;
}

注意需要匹配使用new和delete操作符：

• 申请和释放单个元素的空间：new、delete
• 申请和释放多个元素的空间：new[]、delete[]

3.1.2 new和delete操作自定义类型

class 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*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;
	//内置类型
	int* p3 = (int*)malloc(sizeof(int));
	int* p4 = new int;
	free(p3);
	delete p4;
	//开辟连续自定义类型空间
	A* p5 = (A*)malloc(sizeof(A) * 10);
	A* p6 = new A[10];
	free(p5);
	delete[] p6;
	return 0;
}

从结果上来看，对于new与malloc最大差别在于对自定义类型除了开辟空间以外，还会调用构造函数和析构函数及其进行良好的初始化和控制。对于malloc而言无法对自定义类型进行好的初始化和控制，只负责开辟内存，除此之外内置类型几乎相同（初始化不同）

对于new优于malloc的几点:

• 用法上进行调正，更简洁好用
• 可以控制初始化
• 对于自定义类型，new可以开空间+构造函数
• new配合构造函数，可以更加便捷创建节点等
• new失败了以后抛异常，不需要手动检查

第一点:

int* p0 = (int*)malloc(sizeof(int));
	int* p1 = new int;

第二点:

int* p2 = new int[10];
	int* p3 = new int(10);
	int* p4 = new int[10]{ 1,2,3 };

第三点：

struct ListNode
{
	ListNode* _next;
	int _val;
	ListNode(int val)
		:_val(val)
		,_next(nullptr)
	{}
};
//创建不带哨兵位，同时如果是插入数据，new ListNode(3)即可
ListNode* CreateList(int n)
{
	ListNode head(-1);
	ListNode* tail = &head;
	int val;
	printf("请依次输入%d个节点的值：>", n);
	for (size_t i = 0; i < n; i++)
	{
		cin >> val;
		tail->_next = new ListNode(val);
		tail = tail->_next;
	}
	return head._next;
}

第四点:

void func()
{
	int n = 1;
	while (1)
	{
		int* p = new int[1024 * 1024*100];
		cout <<n<<"->"<< p << endl;
		++n;
	}
}
int main()   
{
   try
	{
		func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
    return 0;
}

这里try和catch就是捕捉异常，这一点到后面有涉及。以上种种都是new的优点，所以我们不推荐再使用malloc/free系列。

四、 new和delete原理及其两个全局函数的实现(operator new/operator delerte)

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

int* p1 = (int*)operator new(10 * 4);
	//int* p1=new int(10*4)
	operator delete(p1);
	//delete(p1)

从代码中可以看出来，new/delete和operator new/operator delete效果上是相同的。那么直接使用new/delete就行，operator new/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)
    //通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果
    //malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施
    //就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
    if (_callnewh(size) == 0)
    {
    // report no memory
    // 如果申请内存失败了，这里会抛出bad_alloc 类型异常
    static const std::bad_alloc nomem;
    _RAISE(nomem);
    }
    return (p);
}
/*
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;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)

可以通过上述两个全局函数的实现，可以知道，operator new实际是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施；如果用户提供该措施就继续申请，否则就抛异常。operator delete最终是通过free来释放空间的。

内置类型:

如果申请的是内置类型的空间，new/malloc与delete/free基本类似，不同的地方是new在申请空间失败时会抛异常，malloc会返回NULL

自定义类型:

new的原理:

• 调用operator new函数申请空间
• 在申请的空间上执行构造函数，完成对象的构造

delete的原理:

• 在空间上执行析构函数，完成对象中资源的清理工作
• 调用operator delete含函数释放对象的空间

new T[N]的原理:

• 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
• 在申请的空间上执行N次构造函数

delete[]的原理:

• 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
• 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

通过汇编，深入立即其中

对于自定义类型转换指令只有两个核心动作调用全局函数及其构造或析构，而内置类型只有调用全局函数。

对此可得:

• operator new是对malloc的封装，如果失败抛异常，实现new
• operator newp[]封装operator new，最终还是malloc
• operator delete对free的封装
• operator delete[]封装operator delete

同时这里需要注意调用顺序上的问题

五、深入了解new和delete工作原理

new是个操作符，在编译时new A会转化为汇编指令调用malloc，一般来说malloc失败会返回空，由于C++是面向对象的过程，malloc失败返回空是不太合适，一般采用抛异常。全局函数operator new来封装malloc，去调正失败的返回情况。

int main()
{
	A* p1 = new A;//operator new+1次构造
	A* p2 = new A[10];//operatorn new[]+10构造
	int* p3=new int[10];//operator new[](占用40个字节)
	delete p1;//1次析构+operator delete
	delete[] p2;//？次析构+operator delete
    delete[] p3;//operator delete
	return 0;
}

结合汇编和代码提供的信息，提出以下问题:

• 编译器如何开始确定所需开辟空间大小
• 为什么p2指向大小为44字节空间，而不是40字节空间
• 为什么编译器知道p2需要调用10次析构函数

回答:

• 由于new属于操作符，在编译时就计算出了所需空间的大小。
• 编译器在所开辟空间位置前面，也是调用operator new函数多开四个字节，用于记录对象个数(针对自定义类型)
• 由于内置类型不需要调用析构函数，对此不需要记录对象个数，而自定义类型需要记录对象个数。delete[]需要通过对象个数才知道调用多少次析构函数。如果将析构函数注释，p2占用空间为40字节。由于编译器会自动生成析构函数，而该析构函数没有发挥占用，编译器会优化导致不需要四个字节记录对象个数，具体需要看编译器是否优化

六、malloc/free系列和new/delete系列的区别

我们将通过用法和底层特性两点说明：

共同点:

• 都是从堆上申请空间，并且需要用户手动释放

不同点:

• malloc和free属于函数，new和delete属于操作符
• malloc申请的空间不会初始化，new可以初始化
• malloc申请空间时，需要手动计算空间并且传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可
• malloc的返回值为void*，在使用事必须强转，new不需要，因为new后跟的是空间的类型
• malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要的，但是new需要捕获异常
• 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

七、delete最好匹配使用

解析说明:图中delete没有匹配使用，导致可能报错。这里p2指向并不是申请空间的第一个位置，第一个位置是operator new[]实现存放对象个数申请的空间。由于空间是不能一块块释放，对此p2释放的位置是错误的，并且不明确需要调用多少次析构函数，可能会造成内存泄漏。如果是delete[] p2，会将p2指针偏移前面四个字节。

但是以上种种情况，导致这个问题是否报错，具体需要看编译器是否进行优化(编译器是否调用析构函数)，对此我们只需要正确的使用delete就行，上面只是了解就行了

八、定位new表达式(placement -new)(了解)

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

new(指针->空间)类型() ：显式调用构造函数对已经有的空间初始化

构造函数不能显式调用，析构可以显式调用（一般不会去调用两次析构的)

class A
{
    public:
    A(int a = 0)
        : _a(a)
        {
            cout << "A():" << this << endl;
        }
    ~A()
    {
        cout << "~A():" << this << endl;
    }
    private:
    int _a;
}
/ 定位new/replacement new
    int main()
{
    // p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没
    有执行
        A* p1 = (A*)malloc(sizeof(A));
    new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
    p1->~A();
    free(p1);
    A* p2 = (A*)operator new(sizeof(A));
    new(p2)A(10);
    p2->~A();
    operator delete(p2);
    return 0;
}

一般没有人会使用，因为这里就是把new分成两部分，那么干嘛不直接使用new更加方便。

使用场景:定位new表达式在实际中，一般是配合内存池使用。因为内存池分配出的内存没有初始化。如果是自定义类型的对象，需要使用new的定义表达式进行显式调构造函数进行初始化。

C++基本放弃了malloc/free系列。关于realloc扩容解决措施，在C++相关容器中它们会自动处理内存的扩容，使得开发者可以更加方便地使用动态大小的数据集合。

九、内存泄漏（了解)

9.1 内存泄漏概念

内存泄漏指因为疏忽或者错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费

9.2 内存泄漏的危害

长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

9.3 内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏

1.堆内存泄漏(Heap leak)

堆内存指的是程序执行种依据须要分配通过malloc/calloc/realloc/new等从堆中分配的一块内存，用完后必须通过调用相应的free或者delete删除。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

2.系统资源泄漏

指程序使用系统分配的资源,比方套接字，文件描述符，管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

到此这篇关于C/C++内存管理：new与delete的使用及原理的文章就介绍到这了,更多相关C++内存管理new与delete内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！