我与C++的爱恋：C++内存管理
温馨提示：这篇文章已超过384天没有更新，请注意相关的内容是否还可用！
🔥个人主页：guoguoqiang. 🔥专栏：我与C++的爱恋
本篇文章我们详细讲解c++中的动态内存管理
一、C/C++内存分布
我们先看一下c/C++中的内存划分
数据段就是我们所说的全局变量，代码段是我们所说的常量区，我们需要重点关注的是堆区（malloc等），这部分是由我们自己控制的
现在再来做一下这个题练习一下：
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";//隐含"/0"
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);
}
选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？1 staticGlobalVar在哪里？2
staticVar在哪里？3 localVar在哪里？4
num1 在哪里？5
char2在哪里？6 *char2在哪里？7_
pChar3在哪里？8 *pChar3在哪里？9
ptr1在哪里？10__ *ptr1在哪里？11
1-----5 C C C A A
6-----11 A A A D A B
全局变量，静态变量 都在静态区。
- 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
- 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口
创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
- 堆用于程序运行时动态内存分配，堆是可以上增长的。
- 数据段–存储全局数据和静态数据。
- 代码段–可执行的代码/只读常量。
二、C语言中动态内存管理
在C语言中，动态内存管理是通过一组标准库函数完成的，包括malloc, calloc, realloc, 和 free。
malloc
用法：void* malloc(size_t size);
功能：分配指定字节数的未初始化内存。它返回一个指向分配的内存的指针。如果分配失败，返回NULL。
示例：int* ptr = (int*)malloc(sizeof(int) ); 这行代码为1个整数分配了内存
calloc(相当于malloc+memset)
用法：void* calloc(size_t num, size_t size);
功能：为指定数量的元素分配内存，每个元素的大小也在参数中指定，并自动初始化所有位为0。如果分配失败，返回NULL。
示例：int* ptr = (int*)calloc(4, sizeof(int)); 这行代码为4个整数分配了内存，并将它们初始化为0。
realloc(可以分为两种，原地扩和异地扩)
用法：void* realloc(void* ptr, size_t size);
功能：调整之前调用malloc或calloc分配的内存块的大小。如果新的大小大于原始大小，可能会移动内存块到新的位置以提供足够的连续空间。如果realloc的第一个参数是NULL，它的行为就像malloc。
示例：ptr = (int*)realloc(ptr, sizeof(int) * 8); 这行代码将之前分配的内存大小调整为8个整数的大小。
free（只能用来释放主动mallloc等的空间）
用法：void free(void* ptr);
功能：释放之前通过malloc, calloc, 或 realloc分配的内存。一旦内存被释放，那块内存就不能再被访问了。
注意：尝试释放未经分配的内存块或多次释放同一个内存块是不安全的，可能导致未定义行为。
当使用realloc时，如果分配失败，原始内存不会被释放。因此，建议先将realloc的返回值赋给一个临时指针，以检查是否分配成功，再重新赋值给原始指针，以避免内存泄漏。
始终确保只对通过malloc, calloc, 或 realloc分配的指针使用free，并且每个分配的内存块只被free一次
三、C++内存管理方式
C++通过new和delete操作符进行动态内存管理。
1.new/delete操作内置类型
C++兼容C语言，内置类型动态申请，用法简化了，功能保持一致。
void Test()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请10个int类型的空间
int* ptr6 = new int[10];
//动态申请10个int类型的空间并初始化前五个为1，2，3，4，5，后五个为0；
int* ptr7 = new int[10]{1,2,3,4,5};
delete ptr4;//单个对象
delete ptr5;
delete[] ptr6;//多个对象
delete[] ptr7;
}
申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，注意：匹配起来使用。
来看一下new的方便之处吧
struct ListNode
{
ListNode* _next;
int _val;
ListNode(int val)
:_next(nullptr)
,_val(val)
{}
};
struct ListNode* CreateListNode(int val)
{
struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
if (newnode == NULL)
{
perror("malloc fail");
return NULL;
}
newnode->_next = NULL;
newnode->_val = val;
return newnode;
}
这是c语言构造一个节点并完成初始化的过程，我们来看c++的实现：
int main()
{
ListNode* mode1 = new ListNode(1);
return 0;
}
new 和 malloc最大区别是 new对于自定义类型除了开空间还会调用构造函数,
delete 和 free最大区别是delete对于自定义类型除了开空间还会调用析构函数.
不过对于内置类型来说几乎一模一样。
class A
{
public:
A(int a = 0)
: _a(a)
{
cout
cout
A* p1 = new A(1);
delete p1;
return 0;
}
void* p;
while ((p = malloc(size)) == 0)
if (_callnewh(size) == 0)
{
// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
static const std::bad_alloc nomem;
_RAISE(nomem);
}
return (p);
}
_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;
}
public:
A(int a = 0)
: _a(a)
{
cout
cout
A* p1 = new A(1);
delete p1;
return 0;
}
public:
Stack()
{
_a = (int*)malloc(sizeof(int) * 4);
_top = 0;
_capacity = 4;
}
~Stack()
{
free(_a);
_top = _capacity = 0;
}
private:
int* _a;
int _top;
int _capacity;
};
int main()
{
Stack* pst = new Stack;
delete pst;
return 0;
}
public:
A(int a = 0)
: _a(a)
{
cout
cout
A* p1 = new A;
A* p2 = new A[10];
delete p1;
delete[]p2;
return 0;
}
public:
A(int a = 0)
: _a(a)
{
cout
cout
A* p1=(A*)malloc(sizeof(A));//p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
new(p1)A;//对已有空间，显式调用构造
return 0;
}
