《C++初阶之内存管理》【内存分布 + operator new/delete + 定位new】
【内存分布 + operator new/delete + 定位new】目录
- 前言:
- ---------------C/C++的内存分布---------------
- C/C++的内存是怎么划分的?
- C/C++的内存分布是怎么样的?
- C语言的动态内存管理方式是什么?
- 关于C语言内存管理的面试题,小伙子你敢试试吗?
- C++的动态内存管理方式是什么?
- 怎么使用new和delete管理内置类型的变量?
- 怎么使用new和delete管理自定义类型的对象?
- 使用new和delete进行内存管理时需要注意什么?
- C语言和C++的动态内存管理方式有什么区别?
- ---------------operator new与operator delete函数---------------
- 什么是operator new与operator delete函数?
- ---------------new/new[] 和delete/delete[] 的实现原理---------------
- new和delete的实现原理是什么?
- new[]和delete[]的实现原理是什么?
- operator new/delete与new/delete的区别是什么?
- ---------------定位new表达式 ---------------
- 什么是定位new?
- 怎么使用定位new对malloc和operator new分配的空间进行初始化?
往期《C++初阶》回顾:
/------------ 入门基础 ------------/
【C++的前世今生】
【命名空间 + 输入&输出 + 缺省参数 + 函数重载】
【普通引用 + 常量引用 + 内联函数 + nullptr】
/------------ 类和对象 ------------/
【类 + 类域 + 访问限定符 + 对象的大小 + this指针】
【类的六大默认成员函数】
【初始化列表 + 自定义类型转换 + static成员】
【友元 + 内部类 + 匿名对象】
【经典案例:日期类】
前言:
🌈hi~ 小伙伴们你们好呀!(。・ω・。)ノ♡ 博主回家休整了几天,充完电满血复活啦~ 💪
今天为大家带来假期里的第一篇重磅博客【内存分布 + operator new/delete + 定位new】!
这可是C++内存管理的核心内容,非常重要哦!✨
这篇博客聚焦于 C++ 的内存管理相关内容,要知道, 💾内存管理可是 C++ 学习中相当核心且关键的部分。🔑
它直接关系到程序的运行效率、稳定性以及资源利用的合理性,无论是日常的程序开发,还是应对更复杂的项目,扎实掌握这部分知识都必不可少。
所以,大家一定要耐心看完呦☕ ( ̄ω ̄;),相信你看完后会对 C++ 的内存机制有更清晰的认识~(•̀ᴗ•́)و
---------------C/C++的内存分布---------------
C/C++的内存是怎么划分的?
内存是计算机中极为关键的资源,如同城市的土地,合理规划才能高效利用。
在 C++ 编程世界里,为实现对这一资源的高效利用,计算机将内存进行了细致的划分,主要分为以下几个区域:
栈区(Stack Segment)
:栈区如同程序员的「临时工作台」,由编译器自动搭建与清理。
函数调用时,
局部变量
(如:int num;)、函数参数
、返回地址
以及临时计算结果
都会被存储于此。它遵循后进先出(LIFO)原则,就像:堆叠盘子般,最后放入的盘子最先取出。
内存地址从高向低连续增长,因底层有专用寄存器(例如:ESP、EBP)快速定位,压栈与出栈操作仅需简单指令,执行效率极高。
但它空间有限,Windows 默认约 1MB,Linux 通常为 8 - 10MB,递归过深或大量局部变量易引发栈溢出,导致程序崩溃。
堆区(Heap Segment)
:堆区是程序的「动态仓库」,灵活应对不确定生命周期的数据存储。
用于存放
new
(C++)或malloc
(C语言)动态分配的内存,例如:int* ptr = new int[10];
创建的数组。堆区相比栈区内存更大,但分配过程复杂,需调用内存分配函数搜索可用空间,若不足还需请求系统扩展。
频繁分配与释放易产生内存碎片,降低使用效率。且堆内存需手动通过
delete
或free
释放,否则会造成内存泄漏,唯有程序结束时,操作系统才强制回收。
数据段(静态区,Data Segment)
:数据段是存储「长效数据的家园」,分为
初始化数据段
和BSS 段
(也可叫做:未初始化数据段)
全局变量
(int global = 1;)、静态全局变量
(static int s_global = 2;)以及函数内的静态局部变量
(void func() { static int s_local = 3; })均存放于此。初始化数据段保存已赋值的变量,BSS 段则存储未初始化变量,程序启动时自动清零。
这些变量自程序启动分配内存,直至结束才释放,生命周期贯穿全程。
代码段(常量区,Code Segment/Text Segment)
:代码段是程序的「核心指令库」与「常量博物馆」。
字符串字面量
(如:“Hello, World!”)、用const修饰的全局常量
(const int PI = 3.14;),部分编译器处理
也存放其中。编译后的机器指令在此有序排列,确保程序按预定逻辑执行。
此区域具备
只读属性
,防止程序运行时意外篡改指令
或常量
,保障执行稳定性与安全性,其内存自程序启动时固定分配,伴随程序始终 。
C/C++的内存分布是怎么样的?
注意:其实C++的内存分布和C语言的内存分布是一样的。
所以:下面我们先来看一段C语言的代码,通过C语言的代码来了解一下其内存是怎么进行分布的,进而来学习一下C++的内存是怎么分布的?
#include <stdio.h>
#include <stdlib.h>// “全局变量” - 存储在静态区/全局区(数据段)
// 生命周期:整个程序运行期间
// 作用域:整个程序可见
int globalvar = 1;// “静态全局变量” - 存储在静态区/全局区(数据段)
// 生命周期:整个程序运行期间
// 作用域:仅在当前文件可见(限制了外部链接性)
static int staticGlobalvar = 1;void Test()
{// “静态局部变量” - 存储在静态区/全局区(数据段)// 生命周期:整个程序运行期间// 作用域:仅在Test函数内可见static int staticVar = 1;// “局部变量”(自动变量) - 存储在(栈区)// 生命周期:函数调用期间// 作用域:当前代码块内int localVar = 1;// “局部数组” - 存储在(栈区)// 生命周期:函数调用期间// 作用域:当前代码块内// 初始化:前4个元素显式初始化,剩余6个元素默认初始化为0int num1[10] = { 1, 2, 3, 4 };// “局部字符数组” - 存储在(栈区)// 生命周期:函数调用期间// 作用域:当前代码块内// 初始化:从字符串常量"abcd"拷贝内容(包括结尾的'\0')char char2[] = "abcd";// “指向字符串常量的指针” - 字符串"abcd"存储在常量区(代码段)// pChar3本身是“局部指针变量”,存储在(栈区)// 生命周期:函数调用期间// 作用域:当前代码块内const char* pChar3 = "abcd";// “动态内存分配” - 存储在(堆区)// ptr1是“局部指针变量”,存储在(栈区)// 分配:16字节空间(4个int)// 注意:分配的内存未初始化,内容不确定int* ptr1 = (int*)malloc(sizeof(int) * 4);// 动态内存分配 - 存储在(堆区)// ptr2是“局部指针变量”,存储在(栈区)// 分配:16字节空间(4个int)// 注意:calloc会将分配的内存初始化为0int* ptr2 = (int*)calloc(4, sizeof(int));// 重新分配内存 - 可能仍在堆区原位置,也可能移动到新位置// ptr3是“局部指针变量”,存储在(栈区)// 重新分配:16字节空间(4个int)// 注意:原ptr2指向的内存会被释放,ptr3可能指向新地址// 如果realloc失败返回NULL,但原ptr2指向的内存仍有效int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);// 释放堆内存// 释放ptr1指向的16字节空间free(ptr1);ptr1 = NULL;// 释放堆内存// 释放ptr3指向的16字节空间// 注意:因为ptr3可能是realloc后的新指针,所以不需要再释放ptr2free(ptr3);ptr3 = NULL;}int main()
{Test();return 0;
}
请你仔细阅读上面的代码完成下面的填空题:
(答案在这些问题的下面,请勿提前借鉴)
选项:A.栈
B.堆
C.数据段 (静态区)
D.代码段 (常量区)
globalvar
在哪里?staticGlobalvar
在哪里?staticVar
在哪里?localvar
在哪里?num1
在哪里?
char2
在哪里?*char2
在哪里?pChar3
在哪里?*pChar3
在哪里?ptr1
在哪里?*ptr1
在哪里?
上阙答案:【C C C A A】
下阙答案:【A A A D A B】
下面的内容是解析,如果上面的问题你都答对了话,我也建议你看一下:
1.
globalvar
在哪里?答案:C. 数据段 (静态区)
解释:
globalvar
是全局变量
,定义在所有函数外部。- 全局变量存储在数据段(静态区),生命周期为整个程序运行期间,作用域为整个程序。
2.
staticGlobalvar
在哪里?答案:C. 数据段 (静态区)
解释:
staticGlobalvar
是静态全局变量
,使用static
修饰。- 静态全局变量同样存储在数据段(静态区),但作用域被限制在定义它的文件内(外部不可见)
3.
staticVar
在哪里?答案:C. 数据段 (静态区)
解释:
staticVar
是静态局部变量
,在函数内部定义但使用static
修饰。- 静态局部变量存储在数据段(静态区),生命周期为整个程序运行期间,但作用域仅限于定义它的函数内部。
4.
localvar
在哪里?答案:A. 栈
解释:
localvar
是普通局部变量
,在函数内部定义且未使用static
修饰。- 局部变量存储在栈区,生命周期为函数调用期间,函数返回后自动销毁。
5.
num1
在哪里?答案:A. 栈
解释:
num1
是局部数组
,在函数内部定义。- 数组本身是局部变量,存储在栈区,其内容(10 个
int
)也在栈上连续分配。
6.
char2
在哪里?答案:A. 栈
解释:
char2
是局部字符数组
,在函数内部定义。- 数组存储在栈区,内容是字符串
"abcd"
的副本(包含末尾的'\0'
)
7.
*char2
在哪里?答案:A. 栈
解释:
*char2
表示数组的第一个元素
(即:字符'a'
)- 由于数组
char2
存储在栈区,其元素也在栈区。
8.
pChar3
在哪里?答案:A. 栈
解释:
pChar3
是局部指针变量
,在函数内部定义。- 指针本身存储在栈区,但其指向的字符串常量
"abcd"
存储在代码段(常量区)
9.
*pChar3
在哪里?答案:D. 代码段 (常量区)
解释:
*pChar3
表示指针指向的第一个字符
(即:'a'
)- 由于
pChar3
指向字符串常量"abcd"
,而字符串常量存储在代码段(常量区),因此*pChar3
也在常量区。
10.
ptr1
在哪里?答案:A. 栈
解释:
ptr1
是局部指针变量
,在函数内部定义。- 指针本身存储在栈区,但其指向的内存(通过
malloc
分配)在堆区。
11.
*ptr1
在哪里?答案:B. 堆
解释:
*ptr1
表示指针指向的第一个 int 值
- 由于
ptr1
指向通过malloc
分配的堆内存,因此*ptr1
在堆区。
高地址
┌─────────────┐
│ 栈区 │← localvar, num1, char2, pChar3, ptr1,ptr2,ptr3
├─────────────┤
│ 堆区 │← *ptr1(malloc分配的4个int), *ptr2(calloc分配的4个int) , *ptr3(realloc后的内存块)
├─────────────┤
│ 数据段 │← globalvar, staticGlobalvar, staticVar
├─────────────┤
│ 代码段 │← *pChar3指向的字符串常量
└─────────────┘
低地址
C语言的动态内存管理方式是什么?
在 C 语言中,动态内存管理是通过一组标准库函数实现的,主要用于在程序运行时
动态分配
、使用
和释放内存空间
与编译时自动分配的栈内存不同,动态内存分配更灵活,适用于无法在编译期确定内存大小的场景(例如:动态数组、链表等数据结构)
C 语言提供了四个关键函数用于动态内存管理:
malloc
、calloc
、realloc
和free
1.
malloc
:申请未初始化的内存块
功能:分配指定字节数的内存空间,返回指向该内存起始地址的
void*
指针(需强制类型转换为目标类型)语法:
void* malloc(size_t size); // size 为所需内存的字节数
特点:
- 分配的内存未初始化,内容为随机值(垃圾值)
- 若分配失败(如:内存不足),返回
NULL
,需检查返回值避免野指针示例:
int* arr = (int*)malloc(5 * sizeof(int)); // 分配 5 个 int 类型的空间(20 字节) if (arr == NULL) {perror("malloc failed"); // 处理分配失败exit(EXIT_FAILURE); }
2.
calloc
:申请初始化的内存块
功能:分配指定数量和单个元素大小的内存块,并将内存初始化为 0
语法:
void* calloc(size_t num_elements, size_t element_size); // num_elements 为元素个数,element_size 为单个元素大小
特点:
- 自动计算总字节数(
num_elements × element_size
),避免malloc
中手动计算的误差- 内存块被清零,适合需要初始化的场景(如:数组、结构体)
示例:
int* arr = (int*)calloc(5, sizeof(int)); // 分配 5 个 int 空间,初始化为 0
3.
realloc
:调整已分配内存的大小
功能:修改一个原先由
malloc
或calloc
分配的内存块的大小,可扩大或缩小。语法:
void* realloc(void* ptr, size_t new_size); // ptr 为旧内存指针,new_size 为新内存大小
特点:
- 若
ptr
为NULL
—> 等价于malloc(new_size)
- 若
ptr
不为NULL
且new_size
为0
—> 等价于free(ptr)
- 调整内存时,原有数据会被保留,但新扩展的内存未初始化(若扩大)
- 可能因原内存块附近空间不足,重新分配一块新内存并复制数据,原指针可能失效,需用新返回值更新指针。
示例:
int* arr = (int*)malloc(5 * sizeof(int)); // 初始分配 5 个元素arr = (int*)realloc(arr, 10 * sizeof(int)); // 扩容至 10 个元素 if (arr == NULL) { /* 处理失败 */ }
4.
free
:释放动态分配的内存
功能:释放由
malloc
、calloc
、realloc
分配的内存空间,归还系统。语法:
void free(void* ptr); // ptr 为待释放的内存指针
注意事项:
- 只能释放动态分配的内存,不可释放
栈内存
(如:局部变量地址)或未分配的指针
- 释放后,指针应手动置为
NULL
,避免成为野指针(指向无效内存的指针)- 多次释放同一指针会导致未定义行为(程序崩溃或数据损坏)
示例:
int* arr = (int*)malloc(5 * sizeof(int));// 使用内存...free(arr); // 释放内存 arr = NULL; // 置空指针,防止野指针
关于C语言内存管理的面试题,小伙子你敢试试吗?
void Test()
{int* p2 = (int*)calloc(4, sizeof(int));int* p3 = (int*)realloc(p2, sizeof(int) * 10);// 这里需要free(p2)吗? 如果不需要释放请问这是为什么?free(p3);
}
在上面的这段代码中,不需要手动调用
free(p2)
,原因如下:
realloc
的行为:
- 当
realloc
成功扩展内存时,它会返回一个新的指针(可能与原指针相同,也可能不同)- 如果内存需要搬迁(原空间附近无法扩展),realloc会:
- 分配一块新的足够大的内存区域(本例中为
10 * sizeof(int)
)- 自动将原内存(
p2
指向的内容)复制到新内存- 释放原内存(
p2
指向的空间)- 返回新内存的地址(赋给
p3
)- 因此:一旦
realloc
成功返回,原指针p2
就已经失效,其指向的内存已被自动释放。双重释放风险:
- 如果手动调用
free(p2)
,会导致双重释放(先被realloc
释放,后被手动释放),这是未定义行为,可能导致程序崩溃。正确的写法:
void Test() {int* p2 = (int*)calloc(4, sizeof(int));int* p3 = (int*)realloc(p2, sizeof(int) * 10);if (p3 == NULL) {// 处理分配失败的情况(此时 p2 仍有效,需释放)free(p2);return;}// p2 已被 realloc 自动释放,无需再 free(p2)free(p3); // 只需释放新指针 }
C++的动态内存管理方式是什么?
C++ 的动态内存管理是通过
new
和delete
操作符实现的,用于在程序运行时动态申请
和释放
内存。动态内存分配的特点:
- 在堆区分配内存,通过
new
申请,delete
释放。- 适用于以下场景:
无法在编译时确定内存大小
(如:根据用户输入创建数组)需要长期保存数据
(如:跨函数传递的对象)实现动态数据结构
(如:链表、树)
怎么使用new和delete管理内置类型的变量?
new
:申请动态内存
基本语法:
// 分配单个对象 数据类型* 指针变量 = new 数据类型; // 分配但未初始化 数据类型* 指针变量 = new 数据类型(值); // 分配并初始化(任意C++版本均支持对基础类型的初始化) // 分配数组 数据类型* 指针变量 = new 数据类型[元素个数]; // 分配数组(未初始化) 数据类型* 指针变量 = new 数据类型[元素个数]{值1, 值2, ...}; //分配数组并初始化(C++11起支持列表初始化,C++98需手动赋值)
示例:
int* p1 = new int; // 分配一个 int 类型的内存,未初始化,元素为随机值 int* p2 = new int(10); // 分配一个 int 类型的内存,并初始化为 10int* p3 = new int[5]; // 分配包含 5 个 int 的数组,未初始化,元素为随机值 // C++11:列表初始化(C++98不支持,但可通过循环手动赋值) int* arr1 = new int[3]{1, 2, 3}; // 初始化为{1,2,3} int* arr2 = new int[5]{1, 2}; // 前2个为1,2,其余为0(值初始化) int* arr3 = new int[4]{}; // 全为0
delete
:释放动态内存
基本语法:
// 释放单个对象 delete 指针变量; // 释放单个对象// 释放数组 delete[] 指针变量; // 释放数组(必须与 new[] 配对使用)
示例:
delete p1; // 释放单个 int delete p2; // 释放单个 intdelete[] arr1; // 释放 int 数组 delete[] arr2; // 释放 int 数组 delete[] arr3; // 释放 int 数组
总结:使用new和delete进行管理存储在堆区上面的内置类型的变量
void Test()
{// 动态申请一个int类型的空间,未进行初始化存储随机值int* ptr4 = new int;// 动态申请一个int类型的空间,并初始化为10int* ptr5 = new int(10);// 动态申请10个int类型的空间,未进行初始化存储随机值int* ptr6 = new int[3];// 动态申请10个int类型的空间,并进行部分的初始化:前两个元素初始化为1和2,最后一个元素为随机值int* ptr7 = new int[3]{1,2};delete ptr4;delete ptr5;delete[] ptr6;delete[] ptr7;
}
怎么使用new和delete管理自定义类型的对象?
在 C++ 中,使用
new
和delete
管理自定义类型(类或结构体)的对象时,需要特别注意:
构造函数和析构函数的调用
内存分配的正确性
资源管理的安全性
动态创建和销毁单个对象
语法:
---------------------------动态创建和销毁“单个对象”---------------------------// 创建对象(自动调用构造函数) 类名* 对象指针 = new 类名(构造参数); // 带参数的构造函数 类名* 对象指针 = new 类名; // 默认构造函数(若存在)// 销毁对象(自动调用析构函数) delete 对象指针;
示例:
class Resource
{
public:// 构造函数:初始化资源Resource(const string& name) : _name(name){cout << "创建资源: " << _name << endl;}// 析构函数:释放资源~Resource(){cout << "释放资源: " << _name << endl;}private:string _name;
};// 使用示例
void test()
{// 创建对象(调用构造函数)Resource* res = new Resource("文件");// 使用对象...// 销毁对象(调用析构函数)delete res;
}
动态创建和销毁对象数组
语法:
---------------------------动态创建和销毁“对象数组”---------------------------// 创建对象数组(为每个元素调用构造函数) 类名* 数组指针 = new 类名[元素数量]; // 使用默认构造函数 类名* 数组指针 = new 类名[元素数量]{初始化列表}; // C++11+:列表初始化// 销毁数组(为每个元素调用析构函数) delete[] 数组指针; // 必须使用 [],否则内存泄漏
示例:
class Point
{
public:int _x, _y;Point() : _x(0), _y(0) { cout << "默认构造" << endl; }Point(int x, int y) : _x(x), _y(y) { cout << "带参构造" << endl; }
};// 创建数组示例
void testArray()
{// 创建数组(调用3次默认构造函数)Point* arr1 = new Point[3];// C++11+:列表初始化(调用带参构造函数)Point* arr2 = new Point[2]{ Point(1,1), Point(2,2) };// 销毁数组(必须用 delete[])delete[] arr1;delete[] arr2;
}
使用new和delete进行内存管理时需要注意什么?
C++在使用new和delete进行内存的管理的时候需要注意的事项有以下几点:
- 配对使用:
对象与数组区分
- 防止内存泄露:
及时释放
- 避免野指针:
指针置空
- 异常安全:
异常处理
- 深拷贝与浅拷贝:
自定义拷贝控制
下面我们来详细的学习一下上面的5点的注意事项:
配对使用
- 对象与数组区分:
new
用于分配内存,delete
用于释放内存。要确保new
和delete
正确配对,使用new
分配的内存用delete
释放;使用new[]
分配数组内存,就得用delete[]
释放 ,不匹配使用会导致未定义行为 。
int* p = new int;
,后续需用delete p;
释放int* arr = new int[5];
,则需delete[] arr;
释放
防止内存泄漏
- 及时释放:使用
new
分配的内存,必须在不再使用时用delete
释放。
- 若忘记释放,随着程序运行,被占用的内存无法回收,会导致内存泄漏,使程序占用内存越来越多,最终可能耗尽系统内存,影响程序性能甚至导致程序崩溃 。
- 例如:在函数中
int* ptr = new int;
,函数结束前需delete ptr;
避免悬挂指针(野指针)
- 指针置空:释放内存后,原来指向该内存的指针就成为悬挂指针(野指针),继续使用会导致程序崩溃或出现不可预测的行为。所以在
delete
之后,应将指针设置为nullptr
。
- 例如:
int* p = new int; delete p; p = nullptr;
异常安全
异常处理:当
new
操作因内存不足等原因失败时,会抛出std::bad_alloc
异常。为避免程序因异常终止,在使用new
时,建议使用try-catch
块等异常处理机制来捕获和处理异常 。try {int* ptr = new int[100000000]; // 可能因内存不足抛出异常 } catch (const std::bad_alloc& e) {std::cerr << "内存分配失败: " << e.what() << std::endl; }
深拷贝与浅拷贝
自定义拷贝控制:
如果自定义类中包含指针成员等动态资源,需要正确实现
拷贝构造函数
和赋值运算符
,避免浅拷贝问题。否则在对象拷贝或赋值时,可能出现多个对象的指针成员指向同一块内存,当对象析构或释放内存时,会导致重复释放或内存泄漏等问题 。
class MyClass { public:MyClass(int* ptr) : data(ptr) {}// 未定义拷贝构造函数和赋值运算符,存在浅拷贝问题private:int* data; };
应修改为:
class MyClass { public:MyClass(int* ptr) :data(new int(*ptr)) {}// 拷贝构造函数MyClass(const MyClass& other) :data(new int(*other.data)) {}// 赋值运算符MyClass& operator=(const MyClass& other) {if (this != &other) {delete data;data = new int(*other.data);}return *this;}~MyClass() {delete data;} private:int* data; };
C语言和C++的动态内存管理方式有什么区别?
C++的动态内存管理方式和C语言的动态内存管理方式的区别主要有以下5点:
- 操作符/函数
- 类型安全
- 内存初始化
- 内存释放和资源管理
- 错误处理
下面的内容我们来详细的讲解一下上面的5点区别:
C++ 和 C 语言的动态内存管理方式存在多方面区别:
1.
操作符 / 函数
- C 语言:主要通过库函数
malloc
、calloc
、realloc
来分配内存 ,用free
函数释放内存。
- 这些都是
标准库函数
,需要包含<stdlib.h>
头文件才能使用 。- 使用
malloc
分配内存:int* ptr = (int*)malloc(sizeof(int));
- 使用
free
释放内存:free(ptr);
- C++:使用
new
操作符分配内存 ,delete
操作符释放内存;对于数组,用new[]
分配,delete[]
释放。
- 它们是 C++ 语言的
关键字
- 单一对象分配/释放:分配时
int* ptr = new int;
,释放时delete ptr;
- 对象数组分配/释放:分配时
int* arr = new int[5];
,释放delete[] arr;
2.
类型安全
- C 语言:
malloc
、calloc
、realloc
返回的是void*
类型的指针,使用时需要进行强制类型转换 。
- 例如:
int* ptr = (int*)malloc(sizeof(int));
,如果类型转换错误,可能导致编译错误或运行时错误。- C++:
new
操作符会自动根据要创建对象的类型返回相应类型的指针,无需强制类型转换 。
- 例如:
int* ptr = new int;
,返回的就是int*
类型指针,更符合类型安全原则。
3.
内存初始化
- C 语言:
malloc
分配的内存不会进行初始化,其内容是不确定的垃圾值 ;calloc
会将分配的内存初始化为 0
int* ptr = (int*)malloc(sizeof(int));
,此时*ptr
的值不确定int* arr = (int*)calloc(5, sizeof(int));
,此时数组arr
的每个元素都是 0- C++:
new
操作符在分配内存后:
- 对于内置类型,如果提供初始值则会进行初始化。
- 例如:
int* ptr = new int(5);
,指针ptr
指向的int
值为 5- 对于自定义类型,会调用相应的构造函数进行初始化 。
- 例如:
class A { public: A() { std::cout << "构造函数被调用" << std::endl; } }; A* a = new A;
,此时会调用A
的构造函数
4.
内存释放与资源管理
- C 语言:
free
函数只是简单地释放malloc
、calloc
、realloc
分配的内存空间,不会调用对象的析构函数(如果是自定义类型对象)
- 例如:自定义类
class B { public: ~B() { std::cout << "析构函数被调用" << std::endl; } }; B* b = (B*)malloc(sizeof(B)); free(b);
,这里free(b)
不会调用B
的析构函数,可能导致资源泄漏等问题。- C++:
delete
操作符在释放自定义类型对象内存时,会自动调用对象的析构函数 。
- 对于数组,
delete[]
会为每个元素调用析构函数。
- 例如:
B* arrB = new B[3]; delete[] arrB;
,会依次调用 3 个B
对象的析构函数,确保对象内部资源得到正确清理。
5.
错误处理
- C 语言:
malloc
、calloc
、realloc
函数在内存分配失败时返回NULL
,需要手动检查返回值来判断分配是否成功。
- 例如:
int* ptr = (int*)malloc(sizeof(int)); if (ptr == NULL) { // 处理内存分配失败情况 }
- C++:
new
操作符在内存分配失败时会抛出std::bad_alloc
异常 ,需要使用异常处理机制(如:try-catch
块)来捕获和处理异常。
- 例如:
try { int* ptr = new int; } catch (const std::bad_alloc& e) { std::cerr << "内存分配失败: " << e.what() << std::endl; }
总体而言:C++ 的动态内存管理方式(
new
/delete
)相比 C 语言(malloc
/free
等)在类型安全、对象初始化与资源管理等方面具有一定优势,更符合面向对象编程的理念 。但 C 语言的方式也有其灵活性,在一些特定场景(如:与 C 代码兼容等)下仍会使用 。
对比维度 | C++ (new /delete ) | C (malloc /free ) |
---|---|---|
操作符/函数 | 使用操作符:new 、new[] 、delete 、delete[] | 使用函数:malloc() 、calloc() 、realloc() 、free() |
类型安全 | 自动类型推导,无需强制转换 (如:int* p = new int;`) | 需要显式类型转换 (如: int* p = (int*)malloc(sizeof(int)); ) |
内存初始化 | new :调用构造函数 new Type() :值初始化new Type[N]{} :列表初始化 | malloc :不初始化calloc :清零初始化 不调用构造函数 |
内存释放和资源管理 | delete :调用析构函数后释放内存 delete[] :对数组每个元素调用析构函数 | free :仅释放内存,不调用任何清理函数 需手动释放资源(如:文件句柄) |
错误处理 | 默认抛出std::bad_alloc 异常可通过 new (nothrow) 返回nullptr (C++17起更明确) | 返回NULL 表示失败 需手动检查返回值(如: if (!p) { /* 处理错误 */ } ) |
#include <iostream>
using namespace std;
class A
{
public:/*-------------------------构造函数(带默认参数)-------------------------*/ A(int a = 0): _a(a) {std::cout << "A():" << this << std::endl; // 构造函数调用时打印对象地址}/*-------------------------析构函数-------------------------*/~A(){std::cout << "~A():" << this << std::endl; // 析构函数调用时打印对象地址}private:int _a;
};int main()
{// ============== 自定义类型的内存分配对比 ==============cout << "自定义类型的内存分配对比" << endl;/*------------使用malloc和new在堆区开辟“单一对象空间”的对比------------*/// 1. 使用malloc分配内存 - 不会调用构造函数// 只分配内存空间,不进行对象构造A* p1 = (A*)malloc(sizeof(A)); // 只分配空间,无构造// 2. 使用new分配内存 - 会调用构造函数// 分配内存空间并调用构造函数初始化对象A* p2 = new A(1); // 分配空间并构造,参数1传递给构造函数/*------------使用free和delete在堆区释放“单一对象空间”的对比------------*/free(p1); // 只释放内存,不调用析构函数delete p2; // 先调用析构函数,再释放内存// ============== 内置类型的内存分配对比 ==============cout << "内置类型的内存分配对比" << endl;// 4. 内置类型使用malloc和new几乎相同int* p3 = (int*)malloc(sizeof(int)); // C风格分配int* p4 = new int; // C++风格分配// 释放方式free(p3); // C风格释放delete p4; // C++风格释放// ============== 数组内存分配对比 ==============cout << "数组内存分配对比" << endl;/*------------使用malloc和new在堆区开辟“对象数组空间”的对比------------*/// 5. 使用malloc分配对象数组 - 不调用构造函数A* p5 = (A*)malloc(sizeof(A) * 10); // 只分配空间,不构造对象// 6. 使用new分配对象数组 - 调用每个元素的构造函数A* p6 = new A[10]; // 分配空间并调用10次默认构造函数/*------------使用malloc和new在堆区释放“对象数组空间”的对比------------*/free(p5); // 只释放内存,不调用析构函数delete[] p6; // 调用每个元素的析构函数,再释放内存// 注意:必须使用delete[]来释放数组,使用delete会导致未定义行为return 0;
}/*
程序输出分析:
1. 只有new A(1)会输出构造信息:A():0x...
2. 只有delete p2和delete[] p6会输出析构信息:~A():0x...
3. malloc/free不会触发构造/析构函数调用
4. 对于内置类型,new/delete和malloc/free行为几乎相同
5. 对象数组必须使用delete[]释放,否则会导致内存泄漏
*/
---------------operator new与operator delete函数---------------
什么是operator new与operator delete函数?
operator new
和operator delete
: 是用于内存分配和释放的底层函数,它们构成了动态内存管理的基础。
- 它们是 C++ 标准库中预定义的
全局函数
,负责实际的内存分配与释放(类似 C 语言的 malloc 和 free)- 它们是
静态函数
,不依赖于任何对象实例,可以直接调用
与
new
/delete
操作符的关系
new
表达式(如:int* p = new int;
)的执行流程:
- 调用
operator new
分配原始内存。- 在分配的内存上调用对象的构造函数。
delete
表达式(如:delete p;
)的执行流程:
- 调用对象的析构函数。
- 调用
operator delete
释放内存。
---------------new/new[] 和delete/delete[] 的实现原理---------------
new和delete的实现原理是什么?
new
和delete
:是用于动态内存管理的操作符,它们的实现原理涉及到内存分配
、对象构造与析构
等方面,具体如下:
new
的实现原理:1. 调用operator new分配内存:new操作符在底层首先会调用全局的operator new函数(可以自定义重载)来分配所需大小的内存空间。
operator new函数的默认实现通常基于malloc函数,其过程大概如下:
- 尝试通过
malloc
分配指定大小(size_t
类型参数表示)的内存。
- 如果
malloc
分配成功:直接返回分配到的内存指针- 如果
malloc
分配失败:operator new
会尝试执行用户设置的空间不足应对措施(通过set_new_handler
设置)
- 如果存在该措施:则继续尝试分配内存。
- 如果没有设置或尝试后仍失败:就会抛出
std::bad_alloc
类型的异常来表明内存分配失败 。
2. 调用构造函数初始化对象(针对自定义类型):在成功分配内存后:
如果
new
创建的是自定义类型
(类或结构体)的对象:
new
操作符会在分配得到的内存上调用该类型的构造函数,对对象进行初始化,完成从一块原始内存到一个可用对象的转变。
- 定义
class A { public: A() { std::cout << "构造函数被调用" << std::endl; } };
,执行A* a = new A;
时,在operator new
分配好内存后,就会调用A
的构造函数 。如果new创建的是
内置类型
(如:int
、double
等)的变量:
如果提供了初始值(如:
int* ptr = new int(5);
),则将对应内存初始化为给定值如果未提供初始值(如:
int* ptr = new int;
),则值是未定义的(类似分配的原始内存状态)
delete
的实现原理:1. 调用析构函数清理对象资源(针对自定义类型):当使用
delete
操作符时 :
如果删除的是
自定义类型
的对象,首先会调用该对象的析构函数。析构函数会清理对象在生命周期内所管理的资源,
- 例如:释放对象内部动态分配的内存、关闭打开的文件句柄等。
- 如上述:
class A
,执行delete a;
时,会先调用A
的析构函数。如果删除的是
内置类型
的对象,由于没有资源清理的需求,此步骤直接跳过。
2. 调用operator delete释放内存:
在调用完析构函数(如果有)之后,
delete
操作符会调用全局的operator delete
函数(也可自定义重载)来释放对象所占用的内存。operator delete函数的默认实现基于free函数,它会将之前
operator new
分配的内存归还给系统堆内存,供后续重新分配使用 。
new[]和delete[]的实现原理是什么?
对于数组形式的
new[]
和delete[]
:
new[]
在分配数组内存时:(针对自定义类型)
- 除了为数组元素分配足够的内存空间外,还会额外多分配 4 字节来记录数组元素的个数。这是为了保证 delete[] 能够正确知道需要调用几次析构函数。
delete[]
在释放数组内存时:(针对自定义类型)
- 会根据之前记录的元素个数,依次调用每个数组元素的析构函数,然后再调用 operator delete[] 函数释放整个数组占用的内存空间 。
总之:
new
和delete
通过与operator new
和operator delete
函数协作,以及对构造函数
和析构函数
的调用,实现了 C++ 中动态内存的分配与释放,同时兼顾了对象的初始化与资源清理等操作 。
operator new/delete与new/delete的区别是什么?
特性 | new /delete 表达式 | operator new /delete 函数 |
---|---|---|
本质 | 语言内置操作符 | 全局静态函数 |
功能 | 分配内存 + 调用构造函数 | 仅分配原始内存 + 不调用构造 |
能否重载 | 否 | 是 |
常见用途 | 动态创建对象 | 自定义内存管理策略 |
---------------定位new表达式 ---------------
什么是定位new?
定位 new(Placement New)
:是一种特殊的new
表达式,允许在已分配的内存块上构造对象,而无需额外分配内存。
- 它的核心作用是将对象构造与内存分配
解耦
,常用于内存池、嵌入式系统、高性能编程等场景。- 在实际开发中,定位 new 表达式通常会与内存池配合使用。
- 由于内存池分配的内存并未经过初始化,
- 因此若要在这块内存上创建自定义类型的对象,就需要借助定位 new 表达式来显式调用构造函数,
- 从而完成对象的初始化工作。
定位new的语法:
new (内存地址) 类型(构造参数);
内存地址
:必须是一个void*
指针,指向已分配的内存块类型
:要构造的对象类型构造参数
:传递给对象构造函数的参数(可选)
代码示例:在预分配内存上构造对象
#include <iostream>
#include <new> // 必须包含此头文件using namespace std;class Point
{
public:int _x, _y;Point(int x = 0, int y = 0) : _x(x), _y(y){cout << "构造 Point(" << _x << ", " << _y << ")" << endl;}~Point(){cout << "析构 Point(" << _x << ", " << _y << ")" << endl;}
};int main()
{// 1. 预分配内存(可通过 malloc、new 或栈内存)char* buffer = new char[sizeof(Point)]; // 堆上分配// 或:char buffer[sizeof(Point)]; // 栈上分配// 2. 使用定位new在buffer上构造对象Point* p = new (buffer) Point(10, 20);// 3. 使用对象cout << "p->x: " << p->_x << ", p->y: " << p->_y << endl;// 4. 手动调用析构函数(定位new不会自动调用析构)p->~Point();// 5. 释放预分配的内存(如果是堆上分配的)delete[] buffer;return 0;
}
定位 new 的核心特点:
不分配内存,只构造对象
定位 new
不会调用operator new
分配内存,而是直接在指定地址上构造对象- 内存必须提前分配,且大小和对齐方式需满足对象要求
需手动调用析构函数
- 定位 new 构造的对象不会自动析构,需显式调用析构函数(如:
p->~Point();
)- 若忘记调用析构函数,会导致资源泄漏(如:动态分配的内存未释放)
内存来源灵活
- 可以使用堆内存(如:
new char[]
)、栈内存(如:局部数组)或共享内存- 适用于需要精确控制内存位置的场景(如:嵌入式系统中的特定地址)
怎么使用定位new对malloc和operator new分配的空间进行初始化?
#include <iostream>
using namespace std;class A
{
public:/*------------构造函数,带默认参数(a默认为0)------------*/A(int a = 0): _a(a) {cout << "A():" << this << endl; // 输出构造函数调用信息及对象地址}/*------------析构函数------------*/// ~A(){cout << "~A():" << this << endl; // 输出析构函数调用信息及对象地址}private:int _a;
};// 定位new(placement new)的使用示例
int main()
{/*------------示例1:使用malloc分配内存 + 定位new构造对象------------*/cout << "使用malloc分配内存 + 定位new构造对象" << endl;// 1. 使用malloc分配一块与A对象大小相同的内存// 此时p1指向的是未初始化的内存,还不是一个合法的A对象(构造函数未调用)A* p1 = (A*)malloc(sizeof(A));// 2. 使用定位new在已分配的内存上构造A对象// new(p1)A; 会在p1指向的内存上调用A的构造函数// 如果A的构造函数需要参数,应该写成 new(p1)A(参数);new(p1)A; // 这里调用的是A的默认构造函数(因为a有默认值0)// 3. 显式调用析构函数(因为对象是用定位new构造的,需要手动管理)p1->~A();// 4. 释放malloc分配的内存free(p1);/*------------示例2:使用operator new分配内存 + 定位new构造对象------------*/cout << "使用operator new分配内存 + 定位new构造对象" << endl;// 1. 使用operator new分配内存(与malloc类似,但属于C++的机制)A* p2 = (A*)operator new(sizeof(A));// 2. 使用定位new构造对象,并传入参数10(调用A(int)构造函数)new(p2)A(10);// 3. 显式调用析构函数p2->~A();// 4. 使用operator delete释放内存operator delete(p2);return 0;
}