C++ 内存管理

标签：__ malloc 管理 int C++ 内存 new delete

一、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__   num1 在哪里？__A__   char2在哪里？__A__   *char2在哪里？__A_   pChar3在哪里？__A__      *pChar3在哪里？__D__   ptr1在哪里？__A__        *ptr1在哪里？__B__  2、 填空题：   sizeof(num1) = __40__;   sizeof(char2) = __5__;      strlen(char2) = __4__;   sizeof(pChar3) = __4/8__;     strlen(pChar3) = __4__;   sizeof(ptr1) = __4/8__; 3、 sizeof 和 strlen 区别？ (1). sizeof 计算类类型或者对象所占的字节大小，它是一个编译时的运算符，所以在编译时就可以确定大小。 (2). strlen 就算的是字符串长度(不包括结尾的 \0 字符)，它是一个标准库函数，需要在运行时计算。

 

【说明】 1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。 2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口     创建共享共享内存，做进程间通信。 3. 堆用于程序运行时动态内存分配，堆是可以上增长的。 4. 数据段--存储全局数据和静态数据。 5. 代码段--可执行的代码/只读常量 

 我们一个一个来看：

 

首先我们要知道：在C语言中，数组初始化的数据通常是存在常量区的，而数组被定义在函数内部时，它会被分配在栈区，当数组初始化时，编译器会将常量区中的数据拷贝到数组所在的栈区。 

1、globalVar：是一个全局变量，在数据段(静态区) 2、staticGlobalVar：是一个全局的静态变量，在数据段(静态区)       那么1和2两个变量有什么不同？       答：链接属性不同，globalVar在所以文件都可以用，而staticGlovalVar只在当前文件使用，其他文件不能用。 3、staticVar ：是一个局部的静态变量，在数据段(静态区)       那么2和3又有什么不同呢？       答：staticVar在当前函数可用，staticGlovalVar在当前文件可以用，但是1，2，3，的生命周期是：在整个函数期间都可以用。 4、localVar：临时用的变量，存在栈区。 5、 num1：是一个局部的数组，存在栈区。

看上图： 6、char2：是一个局部的数组，存在栈区。      *char2：数据被拷贝回数组，所以存放在栈区 7、pChar3：是一个指针，存在栈区(const修饰的是*pChar3)              *pChar3：常量区。       像char* arr这样的字符串指针，指向的值是存放在常量区的。 8、ptr1：是一个指针，存放在栈区      *ptr1：malloc是一个动态分配的过程， *ptr指向一块动态内存，存放在堆区

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

void Test ()
{
int* p1 = (int*) malloc(sizeof(int));
free(p1);
// 1.malloc/calloc/realloc的区别是什么？
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
// 这里需要free(p2)吗？
free(p3 );
}

 

1.malloc/calloc/realloc的区别是什么？

malloc: 分配一块指定大小的内存,但不会初始化,内存内容是未定义的(也就是说是随机的)。  如果请求失败，则返回NULL。

calloc: 分配一块足够存储num个元素,每个元素大小为size的内存，并将分配的内存空间初    始化为0。如果请求失败，则返回NULL。

realloc: 调整之前分配的内存块的大小,如果原空间之后的空间不够，就去在堆空间上另找一个合适大小的连续空间来使用，返回一个新的内存空间地址。如果原空间之后空间够用，就直接在原有空间之后直接追加空间，原来空间的数据不发生变化，返回旧的内存空间的起始地址。如果将一个 NULL指针传递给 realloc，并且需要分配一块新的内存，realloc 的行为就与malloc相同。

int* ptr = NULL; // 指针初始化为NULL  
ptr = (int*)realloc(ptr, 10 * sizeof(int)); // 此时等同于malloc

 

上述代码需要free(p2)吗？

不需要单独free(p2)，因为在realloc成功时，p2的内存会被重新分配并释放。

三、C++内存管理方式 

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

1、new/delete操作内置类型  

int main()
{
  // 动态申请一个int类型的空间
  int* ptr1 = new int;
  
  // 动态申请一个int类型的空间并初始化为10
  int* ptr2 = new int(10);
  
  // 动态申请10个int类型的空间
  int* ptr3 = new int[10];

  // 动态申请5个int类型的空间并初始化
  int* ptr4 = new int[5]{1,2,3,4,5}

  delete ptr1;
  delete ptr2;
  delete[] ptr3;
  delete[] ptr4;

  return 0;
}

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

那么new/delete和malloc/free比优势究竟在哪呢？

答：new/delete 和 malloc/free最大区别是 new/delete对于自定义类型，除了开空间 还会调用构造函数和析构函数，内置类型是几乎是一样的。

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

class A
{
public:
	A(int a) :_a(a)
	{
		std::cout << "A(int a)" << std::endl;
	}
	~A()
	{
		std::cout << "~A()" << std::endl;
	}
private:
	int _a;
};
int main()
{
	A* aa = new A(1);
	delete aa;
}

 

注意：在申请自定义类型的空间时， new 会调用构造函数， delete 会调用析构函数，而 malloc 与 free 不会 。

 那么问题又来了，既然会调用构造函数和析构函数，那么编译器是怎么知道调用了多少次构造，多少次析构的呢？

class A
{
public:
	A():_a(1)
	{
		std::cout << "A(int a)" << std::endl;
	}
	~A()
	{
		std::cout << "~A()" << std::endl;
	}
private:
	int _a;
};
int main()
{
	A* aa = new A[10];
	delete[] aa;
	return 0;
}

 

四、4. operator new与operator delete函数

 1、operator new与operator delete函数

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

//operator new 的实现
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 new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间 失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否 则抛异常。这里主要是对malloc进行封装，之所以不直接调用malloc而是通过封装了malloc的operator new来调用，是为了更好的符合C++面向对象的特性。

operator new和malloc最大的区别就是opeator new失败抛异常，而malloc失败返回空 

//operator delete的实现
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)

operator delete：与operator new类似，通过封装free来释放空间。

总结：(1)new的本质：调用opeartor new，再通过operator new 调用 malloc 申请空间。

               调用构造函数

           (2)delete本质：调用析构函数

                调用operator delete，再通过operator delete调用 free 释放空间。

五、new和delete的实现原理  

1、自定义类型

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

2、内置类型 

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

 六、定位new表达式（了解）

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

class A
{
public:
	A(int a) :_a(a)
	{
		std::cout << "A()" << std::endl;
	}
	~A()
	{
		std::cout << "~A()" << std::endl;
	}
private:
	int _a;
};
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，
   // 还不能算是一个对象，因为构造函数没有执行
	A* a1 = (A*)malloc(sizeof(A));
	//对已经存在的空间初始化
	//new(a1)A;//这是构造函数不存在参数的情况，当其构造函数有参数时，需要传参
	new(a1)A(1);
	//显示调用析构函数
	a1->~A();
	free(a1);


	A* a2 = (A*)operator new(sizeof(A));
	//对已经存在的空间初始化
	//a2->A(1);不能这么显示调用构造函数
	new(a2)A(5);

	//显示调用析构函数
	a2->~A();
	operator delete(a2);
	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、内存泄漏  

     a.什么是内存泄漏?

       答：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内 存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对 该段内存的控制，因而造成了内存的浪费。

      b.内存泄漏的危害

答： 长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现 内存泄漏会导致响应越来越慢，最终卡死。

3、内存泄漏分类

 C/C++程序中一般我们关心两种方面的内存泄漏：

a.堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一 块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分 内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

b.系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放 掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

 4、如何检测内存泄漏？

在vs下，可以使用windows操作系统提供的_CrtDumpMemoryLeaks() 函数进行简单检测，该 函数只报出了大概泄漏了多少个字节，没有其他更准确的位置信息。

#include <crtdbg.h>
int main()
{
	int* p = new int[10];
	// 将该函数放在main函数之后，每次程序退出的时候就会检测是否存在内存泄漏
	_CrtDumpMemoryLeaks();
	return 0;
}

 

#include <iostream>  
#include <crtdbg.h>  

int main() {
	// 启用内存泄漏检测  
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

	// 动态分配内存  
	int* leak = new int[10]; // 模拟内存泄漏  

	// 正常的操作  
	std::cout << "Doing some work..." << std::endl;

	// 这里没有 delete leak; 造成内存泄漏  

	// 在程序结束时输出内存泄漏信息  
	_CrtDumpMemoryLeaks(); // 这一行可以选择添加，也可以通过上面的设置自动报告  

	return 0;
}

 

• _CrtSetDbgFlag：用于启用内存调试功能及自动泄漏检查，通常在程序启动时调用。

• _CrtDumpMemoryLeaks：用于输出内存泄漏的报告，通常在程序结束时调用。

如果工程比较大,内存泄漏位置比较多,不太好查时,一般都是借助第三方内存泄漏检测工具处理的。

在Linux平台下，常用的第三方内存泄露检测工具包括：

1. Valgrind：这是一个非常流行的开源工具，能够检测内存泄漏、无效内存访问等问题。使用非常简单，通常只需在命令行中运行valgrind --leak-check=full ./your_program即可。

2. AddressSanitizer（ASan）：这是GCC和Clang提供的一种内存错误检测工具，可以检测内存泄露、越界访问等。使用时需要在编译时加上-fsanitize=address选项。

3. Electric Fence：这个工具能够帮助检测越界访问和非法内存访问，很适合于简单的内存管理问题。

 在Windows平台下，常用的第三方内存泄露检测工具包括：

1. Valgrind (通过 WSL)：

   虽然 Valgrind 主要在 Linux 上使用，但在 Windows Subsystem for Linux (WSL) 环境中也可以使用，可用于检测内存问题。

2. Dr. Memory：

   Dr. Memory 是一个开源的内存检测工具，支持 Windows 和 Linux。它可以检测内存泄漏、未使用的内存、越界访问等。

3. Visual Leak Detector (VLD)：

   这是一个为 Visual C++ 提供的开源内存泄漏检测库。在开发时，可以简单地在项目中集成 VLD，能够在调试输出中报告内存泄漏。

4. AddressSanitizer：

   如果你的项目使用的是 Clang 编译器，可以启用 AddressSanitizer，它能够检测内存泄漏和其他内存错误。

5. Cppcheck：

   虽然 Cppcheck 主要用于静态代码分析，但它也提供了一些内存泄漏检测的功能。

 5、如何避免内存泄漏？

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：      这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智 能指针来管理才有保证。 2.采用RAII思想或者智能指针来管理资源。 3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能。 4. 出问题了使用内存泄漏工具检测。

标签：__,malloc,管理,int,C++,内存,new,delete
From： https://blog.csdn.net/m0_73299878/article/details/142882766