【C++要笑着学】C++动态内存管理 | new/delete底层探索 | new/delete实现原理 | 定位new

举报
柠檬叶子C 发表于 2022/04/11 14:47:01 2022/04/11
【摘要】 我们本章要探索的就是C++的内存管理。单身的同学不用怕了,以后没有对象我们可以 new 一个。

C语言里的 "动态内存管理" 放到 C++ 里面,用起来不是那么爽,所以C++就对这一块进行了升级,本章我们就探索探索 C++的内存管理,顺便复习一下C语言里讲过的动态内存管理的知识。学完本章,单身的同学不用怕了,以后没有对象我们可以 new 一个。



Ⅰ.  C语言内存管理的方式回顾

0x00  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";
	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);
}

1. 选择题:

    选项: A.栈 B.堆 C.数据段 D.代码段

    globalVar在哪里?____    staticGlobalVar在哪里?____
    staticVar在哪里?____    localVar在哪里?____
    num1 在哪里?____
 
    char2在哪里?____        *char2在哪里?___
    pChar3在哪里?____       *pChar3在哪里?____
    ptr1在哪里?____         *ptr1在哪里?____


2. 填空题:
    sizeof(num1) = ____;
    sizeof(char2) = ____;    strlen(char2) = ____;
    sizeof(pChar3) = ____;   strlen(pChar3) = ____;
    sizeof(ptr1) = ____;

🔑 答案:CCCAA  AAADAB


栈区(stack)

 栈又叫堆栈,非静态局部变量/函数参数/返回值等等,栈是向下增长的。

执行函数时,函数内部局部变量的存储单元都可以在栈上创建。

函数执行结束后这些存储单元会被自动释放。栈内存分配运算内置于处理器的指令集中,

拥有很高的效率,但是分配的内存容量是有限的。

栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。


堆区(heap)

 堆用于程序运行时动态内存分配,堆是可以上增长的。

一般由程序员自主分配释放,若程序员不主动不释放,程序结束时可能由操作系统回收。

其分配方式类似于链表。


数据段(data segment)

 静态存储区,数据段存放全局变量和静态数据,程序结束后由系统释放。


代码段(code segment)

 可执行的代码 / 只读常量。代码段存放类成员函数和全局函数的二进制代码。

一个程序起来之后,会把它的空间进行划分,而划分是为了更好地管理。

函数调用,函数里可能会有很多变量,函数调用建立栈帧,栈帧里存形参、局部变量等等。


内存映射段(memory mapping)

 内存映射段是高效的I/O映射方式,用于装载一个共享的动态内存库。

用户可使用系统接口创建共享共享内存,做进程间通信。



0x01  C语言中动态内存管理的方式

【面试题】malloc / calloc / realloc 的区别?

这些我们在C语言章节中都有详细的讲解:【维生素C语言】第十三章 - 动态内存管理

malloc

📜 头文件:stdlib.h

 📚 介绍:malloc 是C语言提供的一个动态内存开辟的函数,该函数向内存申请一块连续可用的空间,并返回指向这块空间的指针。具体情况如下:

      ① 如果开辟成功,则返回一个指向开辟好空间的指针。

      ② 如果开辟失败,则返回一个 NULL 指针。

      ③ 返回值的类型为 void*malloc 函数并不知道开辟空间的类型,由使用者自己决定。

      ④ 如果 size 为 0(开辟0个字节),malloc 的行为是标准未定义的,结果将取决于编译器。


calloc

📜 头文件:stdlib.h

📚 介绍:calloc 函数的功能实为 num 个大小为 size 的元素开辟一块空间,并把空间的每个字节初始化为 0 ,返回一个指向它的指针。


⭕ 对比:

      ① malloc 只有一个参数,而 calloc 有两个参数,分别为元素的个数和元素的大小。

      ② 与函数 malloc 的区别在于 calloc 会在返回地址前把申请的空间的每个字节初始化为 0 。


 💬 验证: calloc 会对内存进行初始化

#include <stdio.h>
#include <stdlib.h>

int main()
{
    // malloc
    int* p = (int*)malloc(40); // 开辟40个空间
    if (p == NULL)
        return 1;
    int i = 0;
    for (i = 0; i < 10; i++)
        printf("%d ", *(p + i));
    free(p);
    p = NULL;

    return 0;
}

 🚩  (运行结果是10个随机值)

#include <stdio.h>
#include <stdlib.h>

int main()
{
    // calloc
    int* p = (int*)calloc(10, sizeof(int)); // 开辟10个大小为int的空间,40
    if (p == NULL)
        return 1;
    int i = 0;
    for (i = 0; i < 10; i++)
        printf("%d ", *(p + i));
    free(p);
    p = NULL;

    return 0;
}

 🚩  0 0 0 0 0 0 0 0 0 0

🔺 总结:说明 calloc 会对内存进行初始化,把空间的每个字节初始化为 0 。如果我们对于申请的内存空间的内容,要求其初始化,我们就可以使用 calloc 函数。



0x03 realloc

📜 头文件:stdlib.h

📚 介绍:realloc 函数,让动态内存管理更加灵活。用于重新调整之前调用 malloc calloc 所分配的 ptr 所指向的内存块的大小,可以对动态开辟的内存进行大小的调整。具体介绍如下:

      ① ptr 为指针要调整的内存地址。

      ② size 为调整之后的新大小。

      ③ 返回值为调整之后的内存起始位置,请求失败则返回空指针。

      ④ realloc 函数调整原内存空间大小的基础上,还会将原来内存中的数据移动到新的空间。


📌 realloc 函数在调整内存空间时存在的三种情况:

      情况1:原有空间之后有足够大的空间。

      情况2:原有空间之后没有足够大的空间。

      情况3:realloc 有可能找不到合适的空间来调整大小。

情况1:当原有空间之后没有足够大的空间时,直接在原有内存之后直接追加空间,原来空间的数组不发生变化。

情况2:当原有空间之后没有足够大的空间时,会在堆空间上另找一个合适大小的连续的空间来使用。函数的返回值将是一个新的内存地址。

情况3:如果找不到合适的空间,就会返回一个空指针。



Ⅱ.  C++动态内存管理方式

0x00 引入

#include <stdlib.h>

void Test_C() {
    int* p1 = (int*)malloc(sizeof(int));
    int* p2 = (int*)malloc(sizeof(int) * 5);
}

C语言内存管理方式在C++中可以继续使用,但有些地方就无能为力而且使用起来比较麻烦。

 为了解决这种问题,C++ 又进化出属于自己的内存管理方式。

通过 newdelete 操作符进行动态内存管理。



0x01 new / delete 操作内置类型

💬 new 开辟空间:

void Test_CPP() {
    // 动态申请一个int类型的空间
    int* p1 = new int;

    // 动态申请一个int类型的空间并初始化为10
    int* p2 = new int(10);

    // 动态申请10个int类型的空间
    int* p3 = new int[10];
}

  是不是非常的爽,而且 new 不需要强制类型转换。


💬 C语言用完之后我们要用 free 函数释放:

#include <stdlib.h>

void Test_C() {
    int* p1 = (int*)malloc(sizeof(int));
    int* p2 = (int*)malloc(sizeof(int) * 5);

    free(p1);
    free(p2);
}


💬 但是在C++里,我们可以用 delete

void Test_CPP() {
    int* p1 = new int;
    int* p2 = new int(10);
    int* p3 = new int[10];    // 多个对象
    
    // 单个对象,delete即可。
    delete p1;
    delete p2;

    // 多个对象,delete[] 。
    delete[] p3;
}


 这些指针要不要置空呢?

从安全角度看,这里当然还是置空一下比较好:

void Test_CPP() {
    int* p1 = new int;
    int* p2 = new int(10);
    int* p3 = new int[3];

    delete p1;
    delete p2;
    delete[] p3;

    p1 = nullptr;
    p2 = nullptr;
    p3 = nullptr;
}

不知道大家还是否记得下面这张图(维生素C语言中讲解free的插图)

只是我们这里用 delete,并用 nullptr 置空了,本质是一样的。



0x03 初始化new数组的问题

 C++98 不支持初始化 new 数组:

int* p = new int[5];

 C++11 允许大括号初始化,我们就可以用 { } 列表初始化:

int* p1 = new int[5]{1,2}         // 1 2 0 0 0
int* p2 = new int[5]{1,2,3,4,5};  // 1 2 3 4 5


0x04 new 和 delete 操作自定义类型

我们知道了,malloc / free new / delete 对于内置类型没有本质区别,

 那么它存在的意义是什么呢?仅仅是因为用法更简洁吗?

 当然不是,因为 new malloc 可以操作自定义类型,我们继续往下看。




malloc 和 new 的对比

我们先来对比一下 mallocnew,俗话说的好,没有对比就没有伤害。

对于自定义类型,你也是可以用 malloc 的。

💬 用 malloc 创建对象:

#include <iostream>
using namespace std;

class A {
public:
	A()
		: _a(0) {
		cout << "A():" << this << endl;
	}
	~A() {
		cout << "~A():" << this << endl;
	}

private:
	int _a;
};

int main(void)
{
	// 动态申请单个A对象和5个A对象数组
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = (A*)malloc(sizeof(A) * 5);
}

对于这种是自定义类型的场景,你继续坚持用C语言的动态内存开辟的手段,

是 彳亍 的,没人会拦你,但是我们在来看看C++的:

int main(void)
{
	// 动态申请单个A对象和5个A对象数组
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = (A*)malloc(sizeof(A) * 5);

	A* p3 = new A;     // 后面只需要跟类型就可以
	A* p4 = new A[5];
}

直接看代码,同样是申请单个A对象和5个对象数组,C++写法明显是是更简单。

 仅仅是因为如此吗?我们再来调试看一看。

🔍 让我看看!

我敲,还有这种功能?玩的这么花的吗,不仅能开内存,还能帮你初始化!

如果是一个数组,new 也会对它初始化。


💬 比如这里的 new A[5] ,它会依次对动态创建的5个对象进行初始化。

真的是太棒了,new 不仅会开内存,还会调用对应的构造函数初始化,多省事?

不仅仅是写法上变得简单了,对于自定义类型来说用起来也特别爽!还有什么理由不用 new 呢?


free 与 delete 的对比

💬 我们来对比一下 free delete,它们都是用来释放内存空间的。

#include <iostream>
using namespace std;

class A {
public:
	A()
		: _a(0) {
		cout << "A():" << this << endl;
	}
	~A() {
		cout << "~A():" << this << endl;
	}

private:
	int _a;
};

int main(void)
{
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = (A*)malloc(sizeof(A) * 5);

	A* p3 = new A;  
	A* p4 = new A[5];

	free(p1);
	free(p2);
    
	delete p3;
	delete[] p4;

    // ...
}

相对的,free 只是把 p1 p2 指向的空间释放掉。

delete 不仅会释 p1 p2 指向的空间,delete 还会调用对应的析构函数。

🔺 总结:

在申请自定义类型的空间时,new 会调用构造函数,

delete 会调用析构函数,而 malloc free 不会。

new:在堆上申请空间 + 调用构造函数输出。

delete:先调用指针类型的析构函数 + 释放空间给堆上。



0x05 建议匹配使用

new     👉  delete 
new[]   👉  delete[] 

malloc  👉  free(A)

  new 对应的是 delete,可以可以 new 出来的用 free 释放?

💡 不建议大家混着用, new 出来的用 free,有的编译器就会爆炸。

int main(void)
{
	A* p4 = new A[5];
	free(p4);	      // delete[] p4;     
}


💬 new[] 出来的 你去 delate 而不是 delate[]  也会崩:

int main(void)
{
	A* p4 = new A[5];
	delete p4;	      // delete[] p4;     
}

 记住一个点就可以了:壹壹对应,匹配使用!malloc/free 和 delete/delete   new[] / delete[] 

(你要过马路你就老老实实走斑马线,不要瞎穿)

其实也不一定会出问题,具体得看编译器的检查机制,但是这个 "不一定" 就带有悬念了。

  所以个人建议,还是老老实实的比较好。




Ⅲ.  new 和 delete 的底层探索

0x00 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)
		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 来申请空间的。

operator delete 最终也是通过 free 来释放空间的。


如果 malloc 申请空间成功就直接返回,否则执行用户提供的空间不足的应对措施,

如果用户提供该措施就继续申请,否则就抛异常。

面向过程的语言处理错误的方式:

返回值 + 错误码解决(这个我们之前学过)。

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    char* p1 = (char*)malloc(1024u * 1024u * 1024u *2u);
    if (p1 == nullptr) {
        printf("%d\n", errno);
        perror("malloc fail");
        exit(-1);
    } else {
        printf("%p\n", p1);
    }

    return 0;
}


而面向对象语言处理错误的方式:

一般是抛异常,C++中也要求出错抛异常 —— try catch(后期会细说)。

#include <iostream>
using namespace std;

int main(void)
{
    char* p2 = nullptr;
    try {
        char* p2 = new char[1024u * 1024u * 1024u * 2u - 1];
    } catch (const exception& e) {
        cout << e.what() << endl;
    }
    printf("%p\n", p2);

    return 0;
}


🔺 C++ 提出 newdelete,主要是解决两个问题:

① 自定义类型对象自动申请的时候,初始化合清理的问题。new / delete 会调用构造函数和析构函数。

new 失败了以后要求抛异常,这样才符合面向语言的出错处理机制。

delete free 一般不会失败,如果失败了,都是释放空间上存在越界或者释放指针位置不对)


0x02  operator new 与 operator delete 的类专属重载

下面代码演示了,针对链表的节点 ListNode 通过重载类专属 operator new / operator delete

实现链表节点使用内存池申请和释放内存,提高效率。


💬 我们先看看按照C的方式写:

struct ListNode {
	ListNode* _next;
	ListNode* _prev;
	int _val;
};


int main(void)
{
	struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
	if (n1 == NULL) {
		printf("malloc failed!\n");
		exit(-1);
	}
	n1->_next = NULL;
	n1->_prev = NULL;
	n1->_val = 0;

	return 0;
}

我们创建节点还需要用 malloc 申请空间,还需要强制类型转换,之后还要自己写上初始化,

因为 malloc 失败返回 NULL,会存在野指针隐患,所以出于安全还要检查一下。


💬 我们再来看看 C++ 的方式:

struct ListNode {
	ListNode* _next;
	ListNode* _prev;
	int _val;

	/* 构造函数*/
	ListNode(int val)
		: _next(nullptr)
		, _prev(nullptr)
		, _val(val) {}
};

int main(void)
{
	ListNode* n2 = new ListNode(0);

	return 0;
}

 而在C++里,因为 new 会自动调用构造函数去完成初始化,就很舒服。

而且还不需要去检查是否开辟失败,因为 new 失败不会返回空,而是抛异常。


💬 我们再举个能用得上析构函数的例子 —— Stack:

#include <iostream>
using namespace std;

class Stack {
public:
	Stack(int capacity = 4)
		: _top(0)
		, _capacity(capacity) {
		_arr = new int[capacity];
	}
	~Stack() {
		delete[] _arr;
		_arr = nullptr;
		_capacity = _top = 0;
	}
	// ...
	
private:
	int* _arr;
	int  _top;
	int  _capacity;
};

int main(void)
{
	Stack st;  // 完事了
	Stack* pst2 = new Stack;  // 开空间 + 构造函数初始化
	delete pst2;  // 析构函数(清理对象中资源)+ 释放空间

	return 0;
}


Ⅳ.  new 和 delete 的实现原理

0x00  对于内置类型

 如果申请的是内置类型的空间,new mallocdelete free 基本相似。

不同的地方是,new / delete 申请和释放的是单个元素的空间,

new[] delete[] 申请的是连续空间。而且 new 再申请空间失败时会抛异常。

A* p3 = new A;      // 开辟单个空间
A* p4 = new A[5];   // 开辟的是连续地5个空间

operator new operator delete 就是对 malloc free 的封装。

operator new 中调用 malloc 后申请内存,失败以后,改为抛异常处理错误,

这样符合C++面向对象语言处理错误的方式。

new Stack
call malloc + call Stack 构造函数   ❌ 如果失败返回0,这不符合C++处理错误的方式

new Stack
call operator new + call Stack 构造函数  ✅  失败抛异常,这就非常滴合适



0x01 对于自定义类型

new 的原理:

① 调用 operator new 函数申请空间。

② 在申请空间上执行构造函数,完成对象的构造。


delete 的原理:

① 在空间上执行析构函数,完成对象中资源的清理工作。

② 调用 operator delete 函数释放对象的空间。


new T[N] 的原理:

① 调用 operator new[] 函数,在 operator new[] 中实际调用 operator new 函数完成 N 个对象空间的申请。

② 在申请的空间上调用 N 次构造函数,对它们分别初始化。

Stack* p1 = new[10];
Stack* pst1 = (Stack*)operator new[](sizeof(Stack) * 10);


delete[] 的原理:

① 在释放的对象空间上执行 N 次析构函数,完成 N 个对象中资源的清理。

② 调用 operator delete[] 释放空间,实际在 operator delete[] 中调用 operator delete 来释放空间。



Ⅴ.  定位new

0x00 引入 - 我想手动初始化

如果不用 new,我想手动调用构造函数初始化,

假设我们这有一块空间,是从内存池取来的,或者是 malloc 出来的、operator new 出来的……

 我就不想用 new,但是我想对他进行初始化,行不行?

A* p = (A*)malloc(sizeof(A));  // 我能不能调用构造函数初始化?

当然可以!定位new表达式帮你!


0x01 定位new表达式

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

简单来说就是,定位new表达式可以在已有的空间进行初始化。

📚 写法:

new(目标地址指针)类型                         // 不带参
new(目标地址指针)类型(该类型的初始化列表)       // 带参

📌 注意:目标地址必须是一个指针


0x02 定位new的使用场景

定位 new 是很有用的!

比如开的空间是从内存池来的,如果想初始化,我们就可以使用它。

因为内存池分配出的内存初始化,所以如果是自定义类型的对象,

需要使用 new 定义的表达式进行显示调用构造函数进行初始化。



0x03 定位new用法演示

不带参定位new:

class A {
public:
	A(int a = 0)
		: _a(a) {
		cout << "A(): " << this << endl;
	}
	~A() {
		cout << "~A(): " << this << endl;
	}

private:
	int _a;
};

int main(void)
{
	A* p = (A*)malloc(sizeof(A));
	new(p)A;   // 定位new

	return 0;
}



带参定位new:

class A {
public:
	A(int a)
		: _a(a) {
		cout << "A(): " << this << endl;
	}
	~A() {
		cout << "~A(): " << this << endl;
	}

private:
	int _a;
};

int main(void)
{
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A(10);

	return 0;
}


💬 模拟一下 new 的行为:

int main(void)
{
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A(10);

    // 模拟一下new的行为
	A* p2 = new A(2); 

	// 等价于:
	A* p3 = (A*)operator new(sizeof(A));
	new(p3)A(3);

	return 0;
}

  没事这么写,其实就是脱裤子放屁,

但是有时候,内存不一定是从堆来的,比如从内存池来的,定位 new 就可以大显神功。

高并发内存池,实现定长内存池的时候就需要使用 定位 new。


析构函数释放

析构函数是可以显式调用的(构造函数不行)

p->~A;
int main(void)
{
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A(1);

	A* p2 = new A(2);
	delete p2;

	// 等价于:
	A* p3 = (A*)operator new(sizeof(A));
	new(p3)A(3);

	p3->~A;
	operator delete(p3);

	return 0;
}




参考资料:

Microsoft. MSDN(Microsoft Developer Network)[EB/OL]. []. .

. C++reference[EB/OL]. []. http://www.cplusplus.com/reference/.

百度百科[EB/OL]. []. https://baike.baidu.com/.

比特科技. C++[EB/OL]. 2021[2021.8.31]. 

📌 笔者:王亦优

📃 更新: 2022.3.28

❌ 勘误:暂无

📜 声明: 由于作者水平有限,本文有错误和不准确之处在所难免,本人也很想知道这些错误,恳望读者批评指正!

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。