C/C++内存管理（超详解）

一只小bit2025-01-20 16:06

目录

1.C/C++内存分布

2.C语言动态内存管理

[2.1 malloc](#2.1 malloc)

[2.2 free](#2.2 free)

[2.3 calloc](#2.3 calloc)

[2.4 realloc](#2.4 realloc)

3.C++动态内存管理

3.1new/delete操作内置类型

3.2new/delete操作自定义类型

[3.3operator new与operator delete函数](#3.3operator new与operator delete函数)

3.4定位new表达式(placement-new)

1.C/C++内存分布

**内存中是如何布局的？**如下图，，一般内存主要分为：代码区、常量区、静态区（全局区）、堆区、栈区这几个区域。

内存分布说明：

  1. 内核空间： 放置操作系统相关的代码和数据。（用户不能直接进行操作 ------ 可以通过调用系统提供的 api 函数）一般是给操作系统预留的内存空间，系统会进行相应的保护。
  2. 栈又叫堆栈：非静态局部变量/函数参数/返回值等等，栈是向下增长的。
  3. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。
  4. 堆用于程序运行时动态内存分配，堆是向上增长的。
  5. 数据段：存储全局数据和静态数据。（如static修饰的变量或在函数外定义的全局变量）
  6. 代码段：可执行的代码/只读常量。****（如常量字符串）

2.C****语言动态内存管理

2.1 malloc

函数信息：

上代码：

cpp 复制代码 
#include<stdio.h>
#include<stdlib.h>
int main()
{
	//开辟10个整型的空间:
	
	int* p = (int*)void* p = malloc(10 * sizeof(int));

	//1.开辟失败
	if(p == NULL)
	{
		perror("main");
		return 0;
	}
	//2.开辟成功
	int i = 0;
	for(i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	//回收空间
	free(p);
	p = NULL;
	return 0;
}

小结：

  1. malloc向堆区申请一块连续的空间，开辟成功返回那块空间的地址，开辟失败返回NULL
  2. 因为malloc函数的返回值是void*类型，在用指针变量接收时，必须强制类型转换为对应类型
  3. 如果malloc开辟失败，可能会对空指针进行非法解引用操作，malloc开辟的空间一定要检查
  4. 使用完空间，要主动回收。因为在回收空间后，那块空间的使用权交给了操作系统，为了避免非法访问，通常会主动将指向那块空间的指针置为NULL

2.2 free

函数信息：

上代码：

cpp 复制代码 
#include<stdio.h>
int main()
{
	int a = 1;
	int* b = &a;
	free(b);//回收空间
	b = NULL;
	return 0;
}

小结：

  1. 如果参数ptr指向的空间不是动态开辟的，那么free函数的行为是标准未定义的
  2. 如果参数ptr是NULL指针，则视为无效代码，因为不能对一个不存在的地址释放空间，这样没有意义！
  3. 关于空间回收：可以是主函数结束后，所有开辟的栈帧会被还给操作系统，也可以是主动把不用的空间主动回收掉。

2.3 calloc

函数信息：

上代码：

cpp 复制代码 
#include<stdio.h>
#include<stdlib.h>
int main()
{
	//malloc与calloc进行对比
	//malloc
	int* p = (int*)malloc(40);
	int i = 0;
	for(i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}
	free(p);
	p = NULL;
	
	//calloc
	int* q = (int*)calloc(10, sizeof(int));
	for(i = 0; i < 10; i++)
	{
		printf("%d\n", *(q + i));
	}
	free(q);
	q = NULL;
	return 0;
}

小结：

  1. 相比于malloc来说，calloc与malloc唯一的不同就是calloc会进行初始化，并且要指定开辟空间的单个大小及个数。

2.4 realloc

函数信息：

上代码：

cpp 复制代码 
#include<stdio.h>
#include<stdlib.h>
int main()
{
	//开辟10个整形大小
	int* p = (int*)calloc(10, sizeof(int));
	if(p == NULL)
	{
		perror("main");
		return 0;
	}
	//如果空间不够，还需要10个整型空间，使用realloc调整空间	
	int* pnew = (int*)realloc(p, 20 * sizeof(int));
	if(pnew != NULL)
	{
		p = pnew;	
	}
	//回收空间
	free(p);
	p = NULL;
	return 0;
}

小结：

realloc开辟空间原理：

  1. realloc在调整空间时，发现后面有足够的空间能调整，则直接紧挨着原空间之后进行调整，并且返回原空间的地址；
  2. realloc在调整空间时，发现后面没有足够的空间能调整，则会找一块能容纳原空间和需要增加的增加空间的新空间，并把原空间的内容全部拷贝到新空间，同时把原空间主动释放掉，最后在返回新空间的地址。

3.C++动态内存管理

3.1new/delete****操作内置类型

关于new和delete我们通过代码来介绍：

cpp 复制代码 
int main()
{
	// 动态申请一个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;
	return 0;
}

讲解 ：
申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，将new[]和delete[]匹配起来使用。如果要进行初始化的话，对于内置类型单个变量使用（初始值），如果是数组则在[]后加上{初始值1，初始值2，初始值3......}；

3.2****new/delete操作自定义类型

上代码：

cpp 复制代码 
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;//这里将delete和C语言中的free混用对于自定义类型来说看不出区别
	          //但对于内置类型有很大概率会出bug，不是好的代码习惯!

	int* p3 = (int*)malloc(sizeof(int)); 
	int* p4 = new int;
	free(p3);
	delete p4;//这样才是正确回收空间操作，malloc匹配free，new匹配delete
	A* p5 = (A*)malloc(sizeof(A) * 10);
	A* p6 = new A[10];//这里可以对A数组进行初始化,可以直接给值，也可以用匿名对象构造初始化
	//A* p7 = new A[10]{ 1,2,3,4,5,6,7,8,9,10 };
	//A* p8 = new A[10]{ A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),A(10) };
	free(p5);
	delete[] p6;
	return 0;
}

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会，这是C++动态操作与C语言动态操作的区别之一，为什么会调用析构和构造函数，请继续往下看：

先来介绍一下operator new和operator delete：

3.3operator new与operator delete函数

先弄清几个点：

  1. new和delete 是用户进行动态内存申请和释放的操作符，
  2. operator new 和operator delete是系统提供的全局函数，
  3. new在底层调用operator new全局函数来申请空间，
  4. delete在底层通过operator delete全局函数来释放空间。

纸上得来终觉浅，我们扒开两个函数的底层实现看看：

cpp 复制代码 
/*
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)

小结：

  1. operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。如何查看异常呢，使用try+catch来捕捉：

    cpp 复制代码 
    #include"iostream"
using namespace std;
class A
{
public:
	A(int year=2025,int month=1,int day=19)
	{
		cout << year << "-" << month << "-" << day << endl;
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}
	~A()
	{
		cout << "Destroy" << endl;
		_year = _month = _day = 0;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	try
	{
		A* tmp = new A[10]{ A(2025,1,10),A(2025,1,11) };//先operator new->malloc再构造
		delete[] tmp;//先析构再operator free->free
	}//malloc失败返回空指针 new失败抛异常捕捉
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

  2. operator delete 最终是通过free来释放空间的。

  3. new操作符首先调用operator new全局函数通过底层malloc开辟一块空间，再调用构造函数对自定义类型初始化。

  4. delete操作符首先调用析构函数销毁自定义类型占用的空间，再调用operator delete全局函数通过底层free释放空间。

3.4定位new表达式****(placement-new)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
new (place_address) type 或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是 配合内存池使用 。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

cpp 复制代码 
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;
}

由于内容太过超前，作者暂且介绍这么多~
- - - - - - ------------------------------本文结束------------------------------ - - - - - -

相关推荐
LucianaiB5 分钟前
C语言之装甲车库车辆动态监控辅助记录系统
android·c语言·开发语言·低代码
我想吃余18 分钟前
高阶C语言|库函数qsort的使用以及用冒泡排序实现qsort的功能详解
c语言·开发语言·数据结构·算法
摇光9324 分钟前
js实现数据结构
开发语言·javascript·数据结构
码上艺术家40 分钟前
手摸手系列之 Java 通过 PDF 模板生成 PDF 功能
java·开发语言·spring boot·后端·pdf·docker compose
念_ovo42 分钟前
【数据结构】AVL树
数据结构·c++
小禾苗_1 小时前
单片机存储器和C程序编译过程
c语言·开发语言
earthzhang20211 小时前
《深入浅出HTTPS》读书笔记（29）：TLS/SSL协议
开发语言·网络协议·算法·https·ssl
m0_dawn1 小时前
算法（蓝桥杯）贪心算法7——过河的最短时间问题解析
开发语言·python·算法·职场和发展·蓝桥杯
试行1 小时前
C++连接使用 MySQL Connector/C++ 库报错bad allocation
java·c++·mysql
java熊猫2 小时前
Kotlin语言的数据库交互
开发语言·后端·golang
热门推荐
01密码学原理技术-第六章-introduction to pulibc-key cryptography02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)04xgboost: Why not implement distributed XGBoost on top of spark05Dell服务器升级ubuntu 22.04失败解决06优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间07leetcode - 1769. Minimum Number of Operations to Move All Balls to Each Box08PyTorch AMP 混合精度中grad_scaler.py的scale函数解析09渗透测试之SQLMAP工具详解 kali自带SQLmap解释 重点sqlmap --tamper 使用方式详解 搞完你就很nice了10Pod的优雅上下线