feng

started from 11.28.2025

首页·个人博客

内存管理

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);
 }

选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里? globaVar是全局变量,全局变量和静态变量都放在静态区.C
staticGlobalVar在哪里? C
staticVar在哪里? C
前两个变量定义在函数之前,在执行Test前就会初始化,后面这个staticVar则是在执行到该语句后才初始化.前两个在哪都能用,作用域是全局的,而staticVar只能在Test内使用
而前两个虽然都是全局变量,但是链接属性不同,globalVar所有文件可见,但是staticGlobalVar只在当前文件可见.
localVar在哪里? A
num1 在哪里? A
char2在哪里? 是一个数组,所以存在栈区 A
*char2在哪里? 数组名是首元素地址,解引用就是首元素,所以还是栈 A
pChar3在哪里? pChar3是地址,存在栈上
*pChar3在哪里? pChar3是地址,指向常量字符串,所以存在常量区 D
ptr1在哪里? ptr1是地址,所以存在栈 A
*ptr1在哪里? ptr1指向的内容是malloc的,解引用后应该存在堆 B
sizeof(num1) = 40;num1是长度为10的数组,sizeof得到的是内存大小.int是4字节,所以大小为10×4=40.
sizeof(char2) = 5;除了”abcd”外,还有个”\0″
strlen(char2)=4; strlen遇到\0就直接结束
sizeof(pChar3) = 4/8;pChar3是个指针,取决于平台

Pasted image 20250926101523.png

操作系统的内存管理:
1.分段:用途不同的数据放到不同的区域.
2.分页:每个进程都要自己的虚拟内存和物理内存,二者之间会进行映射.我们平时看到的都是虚拟地址,去访问空间如果发现没有触发缺页中断,然后就会在中断中建立地址联系.

动态内存管理

动态内存管理指向堆区申请一片空间.
malloc:申请空间;
calloc:申请空间并初始化为0;
realloc:对原本申请的空间进行扩容.
除了这些方式外,C++还提供了新的申请\释放空间的方式.

int main()
{
	int* p2 = new int(10);//申请一个四字节的int空间,初始化为10
	int* p3 = new int[10];//申请10个int的空间,共40字节
	delete p2;
	delete[] p3;
	return 0;
}
Pasted image 20250930102858.png

既然C已经有了malloc和free,那C++的new和delete意义何在?
1.对于申请内置类型的空间,它们效果是意义的,但是如果是申请自定义类型,效果就有区别了

class A
{
private:
	int _a;
public:
	A()
	:_a(0)
	{}
};

int main()
{
	A* a1 = (A*)malloc(sizeof(A));
	A* a2 = new A;
	return 0;
}

得到的结果如下:

Pasted image 20250926111307.png

可以看到,使用new来分配内存时会调用其构造函数进行初始化.同样的,free只会是对内存进行释放,而delete还会调用其析构函数再释放空间.

operator new和operator delete

new/delete是一个操作符,而operator new/delete实际上是一个函数。它的用法与malloc一致

class A
{
private:
	int _a;
public:
	A()
	:_a(0)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
};

int main()
{
	A* a1 = (A*)malloc(sizeof(A));
	A* a2 = new A;
	A* p3 = (A*)operator new(sizeof(A));
	operator delete(p3);
	return 0;
}

得到的结果是:只调用了一次构造函数,是由new调用的,那么operator new有啥用?
operator new和malloc的区别在于对申请失败时的处理。
malloc申请空间失败以后会返回0,而operator new失败后会抛异常(直接让程序崩溃).抛异常的解决方式是可以利用catch对异常进行捕获,实际上是面向对象的一种处理错误的方式.
#补充

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
 {
 // try to allocate size bytes
	 void *p;
	 while ((p = malloc(size)) == 0)
	 {
		 /*
		 operator new:该函数实际通过malloc来申请空间,当malloc申请空间成功时直接返回;申请空间失败,尝试执行空间不足应对措施,如果该应对措施用户设置了,则继续申请,否则抛异常
		*/
		if (_callnewh(size) == 0)
		{
			 // report no memory
			 // 如果申请内存失败了,这里会抛出bad_alloc 类型异常
			 static const std::bad_alloc nomem;
			 _RAISE(nomem);
		}
	}
	 return (p);
 }

可以看到:实现为将malloc的结果赋值给p,如果p!=0,也就是申请空间成功,就会跳出while,并将p返回;如果申请失败,p=0,就会进入while调用一个函数_callnewh,这个函数内就会抛出bad_alloc的异常.
所以实际上,operator new就是由malloc实现的,在绝大部分时候都和malloc一致,只有分配错误处理上的区别.所以
operator new=malloc+抛异常;new=operator new+构造函数
而operator delete和delete没有区别,只是为了保证对称性.

#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)
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;
 }

默认调用的new是全局的new,但是我们也可也在类中自己定义,重载一个专属的operator new.

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

定位new

假设我想模拟如下行为

int main()
{
	A* p = new A;
	delete p;
	return 0;
}

new=operator new+构造函数,所以我利用operator new申请一块空间,然后调用构造函数.但是构造函数是不能显式调用的,为了能够对一块已经存在的空间调用构造函数进行初始化,我们出现了定位new/replacement new

int main()
{
	A* p3 = (A*)operator new(sizeof(A));
	new(p3)A(10);//定位new:new()+构造函数
	p3->~A();//析构函数是可以显式调用的
	return 0;
}

常见问题

1.malloc/free和new/delete的区别是什么
malloc/free和new/delete的共同点是:都是从堆上申请空间,并且需要用户手动释放。不同的地
方是:

  1. malloc和free是函数,new和delete是操作符
  2. malloc申请的空间不会初始化,new可以初始化
  3. malloc申请空间时,需要手动计算空间大小并传递,new只需在其后跟上空间的类型即可, 如果是多个对象,[]中指定对象个数即可
  4. malloc的返回值为void*, 在使用时必须强转,new不需要,因为new后跟的是空间的类型
  5. malloc申请空间失败时,返回的是NULL,因此使用时必须判空,new不需要,但是new需要捕获异常
  6. 申请自定义类型对象时,malloc/free只会开辟空间,不会调用构造函数与析构函数,而new在申请空间后会调用构造函数完成对象的初始化,delete在释放空间前会调用析构函数完成空间中资源的清理

2.内存泄漏
如果忘记释放开辟的内存就会导致内存泄漏。如果程序长期运行就会导致内存不断被占用造成响应越来越慢,最终导致卡死。泄漏的地址依然在那,但是没有办法再给其他程序使用。

← 上一篇:
下一篇: →