C++：内存管理

最新推荐文章于 2025-05-18 18:05:11 发布

tju新生代魔迷

最新推荐文章于 2025-05-18 18:05:11 发布

阅读量640

点赞数 19

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/2401_88251472/article/details/147874896

版权

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___ main函数中局部变量，存储在栈帧中

num1 在哪里？__A__ 局部变量数组，栈帧中。

char2在哪里？__A__ char2是一个数组，用字符串初始化，开辟五个字节，也是局部数组，在栈帧中

*char2在哪里？__A_ *char2也在栈帧上

pChar3在哪里？__A__ pChar3中const修饰的是指向的内容，不影响PChar3，还在栈帧上

*pChar3在哪里？__D_ *PChar3是一个四个字节的指针变量，PChar3自己在栈帧中存了一个常量字符串的地址（首元素地址），*PChar3就是指向该字符串，在代码段中

ptr1在哪里？__A__ 局部变量的指针，在栈帧中

*ptr1在哪里？__B__ *ptr1指向的东西是由malloc函数创建，malloc动态开辟在堆中

图解：

栈不大，更多的空间预留给堆。

说明：

1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。

2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）

3. 堆用于程序运行时动态内存分配，堆是可以上增长的。

4. 数据段--存储全局数据和静态数据。

5. 代码段--可执行的代码/只读常量。

二，C语言中动态内存管理方式malloc/calloc/realloc/free

void Test ()
{
 // 1.malloc/calloc/realloc的区别是什么？
 int* p2 = (int*)calloc(4, sizeof (int));
 int* p3 = (int*)realloc(p2, sizeof(int)*10);
 
 cout<<p2<<endl;
 cout<<p3<<endl;

 // 这里需要free(p2)吗？
 free(p3 );
}

malloc动态申请空间，calloc在动态申请空间后还会初始化，realloc是对上述开辟的空间进行扩容（原地扩容/异地扩容）

原地扩容：在开辟了的堆区域后进行探查看是否分配，分配了就异地扩容（把整个内容拷贝下来，再把旧的空间释放），未分配就原地扩容（在区域后面扩容）

原地扩容：p2和o3指向同一个地址

异地扩容：p2和p3指向不同的地址

、

异地扩容不需要对p2进行释放

malloc的实现原理，大家可以自行了解学习。

三，C++内存管理方式

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

1，new/delete操作内置类型

注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用 new[ ]和delete[ ]，注意：匹配起来使用。

void Test()
{
  // 动态申请一个int类型的空间  默认情况下是不初始化的
  int* ptr4 = new int;
  
  // 动态申请一个int类型的空间并初始化为10 后面跟上原括号
  int* ptr5 = new int(10);
  
  // 动态申请10个int类型的空间
  int* ptr6 = new int[3];
  
  //动态申请10个int类型的空间并初始化  与数组初始化类似
  int* ptr7= new int[10]{1,2,3,4};
 
  delete ptr4;
  delete ptr5;
  delete[] ptr6;
  delete[] ptr7;
}

2,new和delete操作自定义类型

class A
{
  public:
   A(int a = 0)
    : _a(a)
   {
     cout << "A():" << this << endl;
   }
   ~A()
   {
     cout << "~A():" << this << 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)); // C
   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不会。

struct ListNode
{
	int _val;
	ListNode* _next;

	ListNode(int val)
		:_val(val)
		, _next(nullptr)
	{}
};
int main()
{
	    //C语言开辟一个节点，需要malloc函数等自定义函数
	    //而C++仅仅需要new
	    ListNode* node1 = new ListNode(1);
		ListNode* node2 = new ListNode(2);
		ListNode* node3 = new ListNode(3);
		ListNode* node4 = new ListNode(4);
		node1->_next = node2;
		node2->_next = node3;
		node3->_next = node4;
	
		ListNode* cur = node1;
		while (cur)
		{
			cout << cur->_val << "->";
			cur = cur->_next;
		}
		cout << "nullptr" << endl;
	
		return 0;
}

int main()
{
	size_t x = 0;
	int* ptr1 = nullptr;
	try
	{
		do {
			// ptr1 = (int*)malloc(10 * 1024 * 1024);
			// malloc返回零，需要手动检查
			//ptr1 = new int[500 * 1024 * 1024];
            //new返回异常，抛异常需要在内层或者外层去捕获异常，否则程序结束
			ptr1 = new int[10 * 1024 * 1024];
			if (ptr1)
				x += 10 * 1024 * 1024 * 4;

			cout << ptr1 << endl;
		} while (ptr1);
	}
	catch (const exception& e)//new抛出的异常是exception的派生类
	{
		cout << e.what() << endl;
	}

四，operator new与operator delete函数、

1，operator new与operator delete函数

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

operator new的底层代码逻辑：

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

operatot delete的底层代码逻辑：

/*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;
}

这里的反汇编中可以看出，delete先调用了一层析构函数（00462C7D call），析构中调用operator delete函数。

/*free的实现*/
#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)

总结：
通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果 malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

五，new和delete的实现原理

1，内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是： new/delete申请和释放的是单个元素的空间，new[ ]和delete[ ]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

2，自定义类型

（1）new的原理

1. 调用operator new函数申请空间

2. 在申请的空间上执行构造函数，完成对象的构造

（2）delete的原理

1. 在空间上执行析构函数，完成对象中资源的清理工作

2. 调用operator delete函数释放对象的空间

（3）new T[N]的原理

1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请

2. 在申请的空间上执行N次构造函数

（4）delete[]的原理

1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理

2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

这里用Stack举例看清其中原理：

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}

	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};



int main()
{
	A* p2 = new A;
	A* p4 = new A[5];
}

x86环境下，这里我们通过反汇编发现new A只开了四个字节，而new A[5]缺开了24个字节，这里是为什么呢？

new通常会多开四个字节，这四个字节通常会存储数据个数（对象个数），但p4返回的并不是多开的那四个字节的首地址，而是正常开辟空间的首地址。

而这里delete[]函数，其实也是先回把p4往前偏移四个字节，读取对象个数，确定调用多少次析构函数。

这里使用delete函数会报错，因为p4所指向的位置不对，调用析构函数释放会出错。

当把析构函数注释掉后：

发现new A[5]又只存20个字节，不存对象个数了，其实这里不再调用析构函数后，就不再存储对象个数（相当于一种优化）。

六，定位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;
}

 int main()
{
	// 等价于 new
	A* p1 = (A*)operator new(sizeof(A));
	// 构造函数不支持这样显示调用
	//p1->A(1);
	// 定位new/replacement new 显示调用构造函数
	new(p1)A(10);

	// 等价于delete
	p1->~A();//析构函数支持显式调用
	operator delete(p1);

	return 0;
}

构造函数是自动调用，而非我们显式（主动）调用。

但是析构函数可以显式调用。

这里会有疑问，直接使用new和delete就行，那么为什么要这么写呢？

这里用池化技术（提升性能）解释：

当高频的需要内存时，为了提高效率，就建立了内存池（其实就是提前找系统申请一大块空间）存储起来，自己管理申请和释放。