C++ | 动态内存分配

是奈思呀

已于 2023-06-30 15:18:06 修改

阅读量2.1k

点赞数 2

分类专栏： C++ 文章标签： c++ 开发语言

于 2023-06-06 22:04:38 首次发布

本文链接：https://blog.youkuaiyun.com/Nice_W/article/details/131072227

版权

C++ 专栏收录该内容

26 篇文章

订阅专栏

四、operator new 与 operator delete 函数

五、new和delete的实现原理

六、定位new表达式（replacement new）

七、总结

前言

在学习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";
    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

参考答案（有异议可在评论区评论，会及时回复）

CCCAA

AAAD A与C

二、C语言的动态内存分配

C语言中，我们常用malloc/calloc/realloc 与 free 来进行动态内存的分配；具体用法参考C文档

面试题：malloc、calloc、realloc的功能及区别是什么呢？

这三个函数都是动态内存申请的函数，其中malloc申请的内存并不会初始化，而calloc申请的内存会初始化为0，对于realloc来说，若第一个参数为NULL，功能就如同malloc函数，而若不为空，则是对指向区域进行扩容，这里还会分为两种情况，若当前空间后面的空间足以支撑扩容后的容量，则原地扩容，若不足，则会重新找一块足够大的区域，并拷贝原来空间中的数据，并释放原来的空间；

注意：这三个函数若申请空间失败，则返回NULL

三、C++的内存管理方式

1、初始new与delete

由于C++向下兼容C，因此C++也可以使用C语言的方式动态内存管理，但是C++提出了一套新的管理方式；C++可通过 new 和 delete 操作符的方式进行动态内存管理；

1、

new 类型 --- 为该类型对象在堆上申请一块空间（配合delete使用）

delete 指向该申请变量的指针 --- 释放申请的空间

2、

new 类型[申请该类型变量的数量] --- 为该类型申请指定数量的一块连续的空间（配合 delete[] 使用）

delete[] 申请空间的起始地址 --- 释放申请的连续空间

注意：对于申请空间的初始化，若是单个对象，后面使用圆括号即可，若是多个对象，用花括号将其括起来，并用逗号分隔开；

int main()
{
	// C语言
	int* p1 = (int*)malloc(sizeof(int)); // 不初始化
	if (nullptr == p1)
	{
		perror("malloc fail");
		exit(-1);
	}
	// 申请一块连续的空间 -- 不初始化
	int* p2 = (int*)malloc(sizeof(int) * 10);
	if (nullptr == p2)
	{
		perror("malloc fail");
		exit(-1);
	}
	// 释放空间
	free(p1);
	free(p2);

	// C++
	int* p3 = new int; // 不初始化
	int* p4 = new int(10); // 初始化
	//申请一块连续的空间
	int* p5 = new int[10]; // 不初始化
	int* p6 = new int[10]{ 1,2,3,4,5 };  //	初始化
	// 释放空间
	delete p3;
	delete p4;
	delete[] p5;
	delete[] p6;
	return 0;
}

我们可以看出C++的空间申请，明显比C语言的方式简洁很多，但C++设计出new 与 delete仅仅是为了更加简洁吗？其实C++设计出 new 和 delete 是为了自定义类型；

2、new与delete的特点

当new一个自定义类型时，会调用其构造函数，当delete一个自定义类型时，同样也会调用其析构函数；

class A
{
public:
	A(int a = 10)
		:_a(a)
	{
		cout << "A(int a = 10)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
int main()
{
	// C
	A* pa1 = (A*)malloc(sizeof(A));
	if (pa1 == nullptr)
	{
		perror("malloc fail");
		exit(-1);
	}
	// C++
	A* pa2 = new A;


	free(pa1);
	delete pa2;
	return 0;
}

四、operator new 与 operator delete 函数

new和delete是两个操作符，并不属于函数，而他们实际上分别是调用了 operator new 与 operator delete 这两个全局函数，类似 new 类型[] 版本与delete [] 版本调用的也是 [] 版本的全局函数；以下分别为其实现；

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;
}

看不懂如上函数也没有关系，我们只要知道 operator new底层实际上是将malloc进行了封装，只不过不同的时，其申请失败时，会抛出异常；而operator delete 底层实际上是将free进行了封装，当free失败时，也会抛出异常；operator new[ ] 与 operator delete[ ] 则是重复多次调用 operator new 与 operator delete；

五、new和delete的实现原理

        对于 new 来说，实际上做了两部分工作，首先调用了 operator new 函数，其次如果是自定义类型，则调用其构造函数；

        对于 delete 来说，也是分为两步，首先，如果是自定义类型，调用其析构函数，再调用operator delete 函数；

        对于 new 类型[ ] 来说，同样分为两步，首先调用 operator new[ ]函数，实际上这个函数是调用 operator new 函数来实现的，然后再调用多个对象的构造函数

        对于 delete[] 来说，也是分为两步，首先调用多个对象的析构函数，然后再调用 operator delete[] 函数，而这个函数实则也是调用 operator delete 函数来实现的；

class A
{
public:
	A(int a = 10)
		:_a(a)
	{
		cout << "A(int a = 10)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
int main()
{
    // new -> operator new -> 构造
	A* pa1 = new A;
    // new[] -> operator new[] -> operator new -> 多次构造
	A* pa2 = new A[10];
    // delete -> operator delete -> 析构
	delete pa1;
	// delete[] -> 多次析构 -> operator delete[] -> operator[]
	delete[] pa2;
	return 0;
}

我们查看new一个对象后反汇编后的代码，如下；（同样，其他的也是如此）

六、定位new表达式（replacement new）

当一个对象在申请时未初始化时，后来又想对其初始化，则可以使用定位new来对其初始化（一般是调用malloc、operator new等函数所以未初始化）

语法如下：

new（未初始化对象指针）构造函数

class A
{
public:
	A(int a = 10)
		:_a(a)
	{
		cout << "A(int a = 10)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* pa1 = (A*)operator new(sizeof(A));
	// 定位new
	new(pa1)A(10);

	// 因为构造函数不能显式调用，故出现了定位new  析构函数可以显示调用
	// pa1->~A(10);  // err
	pa1->~A();  // 正确
	return 0;
}

七、总结

关于malloc与new的区别

1、malloc free等为函数，而new、delete为操作符

2、malloc不会初始化，而new可以初始化

3、malloc需要计算类型大小，new只需传数据类型

4、malloc返回值需强转，new不需要

5、malloc失败时返回NULL，而new是抛异常

6、malloc只会申请空间，而new则还会调用构造