// 欢迎来到 aramae 的博客，愿 Bug 远离，好运常伴！ //
时代不会辜负长期主义者，愿每一个努力的人都能达到理想的彼岸。
- 1. C/C++内存分布
- 2. C语言中动态内存管理方式
- 3. C++中动态内存管理
- 4. operator new 与 operator delete 函数
- 5. new 和 delete 的实现原理
- 6. 定位new 表达式（placement-new）
引言： 本章介绍C/C++内存分布，C语言和C++中的动态内存管理方式，operator new 和 operator delete 函数等，后续学习会继续深入补充，这里做简单理解和学习。
1. 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在哪里？_C_ staticGlobalVar在哪里？_C___
staticVar在哪里？__C__ localVar在哪里？__A__
num1 在哪里？__A__
char2在哪里？__A__ * char2在哪里？__A_
pChar3在哪里？__A__ * pChar3在哪里？__D__ptr1在哪里？_A__ *ptr1在哪里？_B__
2. 填空题：
sizeof(num1) = __40__;
sizeof(char2) = __5__; strlen(char2) = __4__;
sizeof(pChar3) = __4 or 8__; strlen(pChar3) = __4__;
sizeof(ptr1) = __4 or 8__;
3. sizeof 和 strlen 区别？
3.1. 本质与功能
sizeof：
- 它属于操作符，而非函数。
- 作用是返回一个类型或者变量所占用的内存字节数，这是在编译阶段就确定好的。
- 对于数组，它会返回整个数组的大小；对于指针，则返回指针本身的大小（一般在 32 位系统下是 4 字节，64 位系统下是 8 字节）。
strlen：
- 这是标准库中的一个函数（原型为
size_t strlen(const char* s)）。- 功能是计算以
'\0'结尾的字符串的实际长度，需要在运行时进行遍历才能确定。- 计算结果不包含字符串结束符
'\0'。3.2. 返回值
sizeof：返回的是size_t类型的值，代表对象的大小。strlen：同样返回size_t类型的值，表示字符串的长度。
| 内存区域 | 分配方式 | 释放方式 | 生命周期 | 存储内容示例 |
|---|---|---|---|---|
| 栈 | 自动 | 自动 | 函数调用期间 | 局部变量、函数参数 |
| 堆 | 手动（malloc/new） | 手动（free/delete） | 程序员控制 | 动态分配的对象 |
| 全局 / 静态区 | 程序启动时 | 程序结束时 | 整个程序运行期 | 全局变量、静态变量 |
| 代码段 | 程序加载时 | 程序结束时 | 整个程序运行期 | 可执行代码、常量字符串 |
【说明】
1. 栈又叫堆栈--非静态局部变量 / 函数参数 / 返回值等等，栈是向下增长的。
2. 内存映射段是高效的I / O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共
享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段（全局/静态区）--存储全局数据和静态数据。
5. 代码段--可执行的代码 / 只读常量。
2. C语言中动态内存管理方式 :malloc/calloc/realloc/free
2.1.
malloc()- 分配内存void* malloc(size_t size);功能：在堆上分配指定大小（以字节为单位）的连续内存空间，不过不会对分配的内存进行初始化
返回值：
- 若分配成功，返回一个指向分配内存起始地址的
void*指针- 若分配失败，返回
NULL#include <stdio.h> #include <stdlib.h> int main() { int* ptr = (int*)malloc(5 * sizeof(int)); // 分配5个int的内存 if (ptr == NULL) { printf("内存分配失败\n"); return 1; } // 未初始化的内存可能包含随机值 for (int i = 0; i < 5; i++) { ptr[i] = i * 10; // 初始化内存 } free(ptr); // 释放内存 return 0; }2. 2
calloc()- 分配并初始化内存void* calloc(size_t num, size_t size);功能：分配
num个大小为size的连续内存块，并且会将所有字节初始化为 0
返回值：
- 若分配成功，返回指向分配内存起始地址的
void*指针- 若分配失败，返回
NULL示例：
#include <stdio.h> #include <stdlib.h> int main() { int* ptr = (int*)calloc(5, sizeof(int)); // 分配5个int并初始化为0 if (ptr == NULL) { printf("内存分配失败\n"); return 1; } // 内存已自动初始化为0 for (int i = 0; i < 5; i++) { printf("%d ", ptr[i]); // 输出: 0 0 0 0 0 } free(ptr); return 0; }2.3
realloc()- 调整内存块大小void* realloc(void* ptr, size_t new_size);功能：
- 若
ptr不为NULL，将ptr所指向的内存块大小调整为new_size字节- 若
ptr为NULL，其作用等同于malloc(new_size)- 若
new_size为 0，其作用等同于free(ptr)，并返回NULL
返回值：- 若调整成功，返回指向新内存块的
void*指针（可能与原指针相同，也可能不同）- 若调整失败，返回
NULL，此时原内存块保持不变示例：
#include <stdio.h> #include <stdlib.h> int main() { int* ptr = (int*)malloc(3 * sizeof(int)); // 初始分配3个int if (ptr == NULL) return 1; // 调整为5个int ptr = (int*)realloc(ptr, 5 * sizeof(int)); if (ptr == NULL) { printf("内存重新分配失败\n"); return 1; } free(ptr); return 0; }2.4
free()- 释放内存void free(void* ptr);功能：释放
ptr所指向的动态分配的内存块，使其能被后续的内存分配使用
注意事项：
ptr必须是之前通过malloc、calloc或realloc返回的指针- 释放后的内存不能再被访问，否则会导致悬空指针错误
- 对
NULL指针调用free()不会产生任何效果#include <stdlib.h> void example() { int* ptr = (int*)malloc(100); // 使用ptr... free(ptr); // 释放内存 // ptr现在是悬空指针，不能再使用 ptr = NULL; // 推荐：将指针置为NULL，避免误操作 }
| 函数 | 分配方式 | 初始化情况 | 用途 |
|---|---|---|---|
malloc() |
分配指定大小 | 不初始化，内容随机 | 基本的内存分配 |
calloc() |
分配多个相同大小的块 | 全部初始化为 0 | 需要初始化为 0 的场景 |
realloc() |
调整已分配内存的大小 | 可能保留原有内容 | 动态调整内存需求 |
free() |
释放内存 | - | 回收不再使用的内存 |
题目：
1.malloc/calloc/realloc的区别？
malloc(size)：分配size字节内存，内容随机，不初始化。calloc(n, size)：分配n * size字节内存，全部初始化为 0。realloc(ptr, new_size)：调整ptr指向的内存大小为new_size，可能移动内存位置，保留原有内容。
https://www.bilibili.com/video/BV117411w7o2/?spm_id_from=333.788.videocard.03. C++ 内存管理
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提 出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。在 C++ 中，有两种方式可以进行动态内存分配，分别是使用new/delete操作符和malloc/free函数。不过，new 和 delete 是更推荐的方式，因为它们能自动调用构造函数和析构函数。
3.1 new/delete操作内置类型
void Test()
{
//动态申请一个int类型的空间
int* ptr4 = new int;
//动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
//动态申请10个int类型的空间
int* ptr6 = new int[10];
delete ptr4;
delete ptr5;
delete[]ptr6;
}
3.2 new/delete操作自定义类型
3.21. 对象的构造与析构
当使用
new创建自定义类型的对象时，会依次执行以下步骤：
- 分配内存：调用
operator new分配原始内存。- 调用构造函数：在分配的内存上构造对象（执行类的构造函数）。
当使用
delete释放对象时，顺序相反：
- 调用析构函数：销毁对象（执行类的析构函数）。
- 释放内存：调用
operator delete释放内存。class MyClass { public: MyClass() { std::cout << "构造函数被调用" << std::endl; } ~MyClass() { std::cout << "析构函数被调用" << std::endl; } }; // 使用new创建对象 MyClass* obj = new MyClass(); // 输出：构造函数被调用 // 使用delete释放对象 delete obj; // 输出：析构函数被调用3.22. 数组的动态分配
使用
new[]创建自定义类型的数组时，会为每个元素调用构造函数；使用delete[]释放数组时，会为每个元素调用析构函数。MyClass* arr = new MyClass[3]; // 输出3次：构造函数被调用 delete[] arr; // 输出3次：析构函数被调用（顺序与构造相反）注意：
- 必须使用
delete[]：如果使用delete而非delete[]，只会调用第一个元素的析构函数，导致内存泄漏。- 元素数量记录：C++ 标准未强制要求记录数组大小，但多数编译器会在分配的内存前额外存储元素数量，以便
delete[]正确调用析构函数。3.23. 带参数的构造函数
new表达式可以传递参数给构造函数：class Point { public: Point(int x, int y) : x(x), y(y) {} private: int x, y; }; // 使用参数初始化对象 Point* p = new Point(10, 20);
class A
{
public :
A(int a = 0)
:_a(a)
{
cout << "A():" << endl;
}
~A()
{
cout << "~A():" << endl;
}
private:
int _a;
};
int main()
{
//new /delete 和 malloc/free最大区别是
//new /delete对于自定义类型除了开空间还会
//调用构造函数和析构函数
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会调用构造函数，delete会调用析构函数，而malloc与free不会
4. operator new与operator delete函数
4.1 operator new 和 operator delete 函数
在 C++ 中，operator new和operator delete是用于内存分配和释放的底层函数，它们与new和delete表达式密切相关，但有本质区别。
new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的 全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局 函数来释放空间。
基本概念
operator new：负责分配原始内存（不调用构造函数）。operator delete：负责释放内存（不调用析构函数）。
与new/delete表达式的关系：
// new表达式的本质
T* ptr = new T(args); // 等价于：
// void* mem = operator new(sizeof(T)); // 分配内存
// T* ptr = static_cast<T*>(mem); // 类型转换
// ptr->T(args); // 调用构造函数（隐式）
// delete表达式的本质
delete ptr; // 等价于：
// ptr->~T(); // 调用析构函数
// operator delete(ptr); // 释放内存/*
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来申请空间，如果malloc申请空间 成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
5. new 和 delete 的实现原理
5.1 内置类型
5.2 自定义类型
- 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来释放空间
6. 定位new 表达式（placement-new）
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式： new (place_address) type或者new (place_address) type(initializer-list) place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景： 定位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;
}结语：感谢相遇
/// 高山仰止，景行行止。虽不能至，心向往之 ///