【C\C++】内存分配 和 动态内存管理方式

内存分类

在C++中，有几个重要的内存区域，每个区域都有不同的意义和用途。我们从内存分配的角度来分析C++各个内存区域的含义：

1. 栈（Stack）：栈是用于存储 局部变量、函数参数以及函数调用信息 的内存区域。它的特点是自动分配和释放，并且遵循后进先出的原则（LIFO）。

栈的大小有限，通常比较小，因此栈上的变量不能太大。

当一个函数被调用时，它的局部变量和参数将在栈上分配内存。当函数返回时，这些内存将自动释放。

---

2. 堆（Heap）：堆是用于 动态分配内存 的区域。通过 “new” 或 “malloc” 等操作符可以在堆上分配内存，并使用指针来访问和操作这块内存。

堆上分配的内存需要手动释放，否则可能导致内存泄漏。堆的大小通常比栈大得多，但也受到操作系统的限制。

---

3. 全局/静态存储区（Global/Static Storage Area）：全局存储区用于存储 全局变量和静态变量 。全局变量具有程序的整个生命周期，而静态变量的生命周期与其作用域相对应。

全局/静态存储区在程序启动时分配，直到程序结束才会释放。

---

4. 常量存储区（Constant Storage Area）：常量存储区用于存储 常量数据 ，如字符串常量。这些数据是只读的，无法修改。

常量存储区通常位于静态存储区中。

---

5. 程序代码区（Code Section）：程序代码区存储了 程序的执行指令 。这个区域通常是只读的，包含了可执行文件的机器指令。

代码区也叫做文本区。

---

需要注意的是，内存区域的名称和具体实现可能因编译器、操作系统或平台而异。上述区域的描述是一般情况下的概念，可以帮助我们理解C++程序中内存的分配和使用方式。

---

题目：知识巩固

根据上述的分类定义，看下面一道经典的题来巩固知识：

---

选择题: 变量位于内存中的位置

A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)

变量	位置	变量	位置
globalVar	~~~	staticGlobal	~~~
staticVal	~~~	localVar	~~~
num1	~~~
char2	~~~	*char2	~~~
pChar3	~~~	*pChar3	~~~
ptr1	~~~	*ptr1	~~~

---

计算题 变量值的大小

sizeof	strlen
sizeof(num1)
sizeof((char2)	strlen(char2)
sizeof((pChar2)	strlen(pChar3)
sizeof(ptr1)

---

答案

根据上述代码，可以完善表格：

A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)

变量	位置	变量	位置
globalVar	C	staticGlobal	C
staticVal	C	localVar	A
num1	A
char2	A	*char2	A
pChar3	A	*pChar3	D
ptr1	A	*ptr1	B

对 *pChar3 的解释：
在C语言中，字符串常量如"abcd"通常被视为字面常量，在编译时存储在代码段中。指针变量pChar3保存着字符串常量"abcd"的首地址，即代码段中字符串的起始位置。

对于上述变量 的 大小/长度 的计算结果：

sizeof	strlen
sizeof(num1) = 4
sizeof((char2) = 5	strlen(char2) = 4
sizeof((pChar2) = 4 / 8	strlen(pChar3) = 4
sizeof(ptr1) = 4 / 8

---

C语言 动态内存管理

在C语言中，动态内存管理是通过以下四个函数来实现的：

• malloc()
• calloc()
• realloc()
• free()

---

malloc / calloc / realloc

作用

malloc：malloc函数用于在堆区分配指定大小的内存。
它接受一个参数，即要分配的字节数。如果分配成功，返回一个指向分配内存起始地址的指针；如果分配失败，则返回NULL。malloc分配的内存不会被初始化，它的内容是未定义的。

calloc：calloc函数也用于在堆区分配内存，但与malloc不同的是，它还会将分配的内存块全部初始化为零
。它需要两个参数，即要分配的元素数量和每个元素的大小。calloc的返回值是一个指向分配内存起始地址的指针。如果分配成功，返回的内存将被清零；如果分配失败，则返回NULL。

realloc：realloc函数用于调整之前通过malloc或calloc分配的内存的大小。它接受两个参数，一个是之前分配内存的指针，另一个是新的内存大小。realloc会尝试重新分配指定大小的内存，并将之前分配的数据复制到新的内存中。如果分配成功，返回新的内存地址；如果分配失败，则返回NULL。如果传递给realloc的指针为NULL，其行为等同于malloc。

区别

主要区别：

• malloc 只负责分配内存，并且不会对分配的内存进行初始化。
• calloc 除了分配内存，还会将分配的内存块清零。
• realloc 用于重新调整内存大小，并且可以在原有内存块中保留数据。需要注意的是，使用realloc重新分配内存时，不能保证原有内存块的内容被保留在同一位置，因此在使用realloc后，要谨慎处理原有指针的引用。

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

int main() {
    int* ptr1;
    int* ptr2;
    int* ptr3;

    // 使用malloc分配内存
    ptr1 = (int*)malloc(5 * sizeof(int));
    if (ptr1 == NULL) {
        printf("内存分配失败！\n");
        return 1;
    }

    printf("使用malloc分配内存后的初始值：\n");
    for (int i = 0; i < 5; i++) {
        printf("%d ", ptr1[i]);
    }
    printf("\n\n");

    // 使用calloc分配内存
    ptr2 = (int*)calloc(5, sizeof(int));
    if (ptr2 == NULL) {
        printf("内存分配失败！\n");
        return 1;
    }

    printf("使用calloc分配内存后的初始值：\n");
    for (int i = 0; i < 5; i++) {
        printf("%d ", ptr2[i]);
    }
    printf("\n\n");

    // 使用realloc重新调整内存大小，并手动初始化新增内存为零
    ptr3 = (int*)realloc(ptr2, 10 * sizeof(int));
    if (ptr3 == NULL) {
        printf("内存分配失败！\n");
        return 1;
    }

    // 将新增的内存空间初始化为零
    memset(ptr3 + 5, 0, 5 * sizeof(int));

    printf("使用realloc重新调整内存大小后的初始值：\n");
    for (int i = 0; i < 10; i++) {
        printf("%d ", ptr3[i]);
    }
    printf("\n\n");

    free(ptr1);
    free(ptr3);

    return 0;
}

输出结果：

使用malloc分配内存后的初始值：
-842150451 -842150451 -842150451 -842150451 -842150451

使用calloc分配内存后的初始值：
0 0 0 0 0

使用realloc重新调整内存大小后的初始值：
0 0 0 0 0 0 0 0 0 0

从输出结果可以看出：

• 使用 malloc 分配的内存没有被初始化，其内容是未定义的；
• 使用 calloc 分配的内存被自动初始化为零；
• 使用 realloc 重新调整内存大小后，新内存中的内容是不确定的，但之前的数据被保留在新内存块中。

---

C++ 内存管理方式

栈： 栈是一块自动管理的内存区域 ，用于存储局部变量和函数调用的上下文信息。在函数调用时，其局部变量会被自动分配在栈上。当函数返回时，这些局部变量会自动被销毁，释放相应的内存空间。 栈上分配的内存管理非常高效，但是分配的内存空间大小是固定的，且生命周期随函数的调用而限制。

栈的模拟实现

堆： 堆是一块动态管理的内存区域，用于存储动态分配的对象 。在C++中，**使用new关键字从堆上分配内存空间，动态创建对象。并使用delete来进行手动进行释放资源。

堆的模拟实现

智能指针： 智能指针是一种包装类 ，可以像一般指针一样访问对象，但内部会自动管理生命周期，当不再需要时会自动释放内存。

智能指针

容器类： C++标准库提供了各种容器类 ，如 std::vector、std::list 等，这些容器类可以自动管理内存分配和释放。它们会自动在堆上分配所需的内存，并在对象生命周期结束时自动释放相应的内存。

---

operator new 与 operator delete

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

new 和 delete 是用户进行 动态内存申请和释放 的操作符，operator new 和 operator delete是 系统提供的全局函数 ，new在底层调用operator new全局函数来申请空间，delete在底层通过operator 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;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)

从上面的代码（两个全局函数的实现）可以看出：
operatornew 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。
operator delete 最终是通过free来释放空间的 。

---

new 与 delete 的实现原理

• 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来释放空间

---

malloc free 与 new delete 的区别

malloc/free和new/delete的共同点是： 都是从堆上申请空间，并且需要用户手动释放 。不同的地方由下面的表格列出:

malloc	new
函数	操作符
申请空间不初始化	初始化
申请空间时，需要手动计算空间大小并传递	new只需在其后跟上空间的类型,多个对象，[]中指定对象个数即可
返回值为void*, 在使用时需要强转	不需要强转，new后跟的是空间的类型
申请空间失败时返回NULL，需要判空	不需要判空，需要捕获异常

---

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

内存泄漏

简单了解内存泄漏