C++内存管理

最新推荐文章于 2024-07-24 08:30:00 发布

嚞譶

最新推荐文章于 2024-07-24 08:30:00 发布

阅读量94

点赞数 3

分类专栏： C++ 文章标签： c++ 算法开发语言

本文链接：https://blog.csdn.net/qq_64404343/article/details/128435822

版权

C++ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

C/C++内存分布

C语言内存管理方式

C++内存管理方式

operator new与operator 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在哪里？____   staticGlobalVar在哪里？____
   staticVar在哪里？____   localVar在哪里？____
   num1 在哪里？____
   
   char2在哪里？____   *char2在哪里？___
   pChar3在哪里？____      *pChar3在哪里？____
   ptr1在哪里？____        *ptr1在哪里？____
2. 填空题：
   sizeof(num1) = ____;
   sizeof(char2) = ____;      strlen(char2) = ____;
   sizeof(pChar3) = ____;     strlen(pChar3) = ____;
   sizeof(ptr1) = ____;
3. sizeof 和 strlen 区别？

第一题答案：C C C A A A A A D A B

第二题答案：40 5 4 4 4 4

第三题答案：sizeof得出的是数据所占内存空间字节数的大小，包含\0，而strlen求的是数据长度大小，不包含终止符\0

为什么呢？

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

C语言内存管理方式

C语言使用malloc/realloc/calloc/free 4种函数进行内存的申请和销毁。

malloc/calloc/realloc三者区别：

malloc只申请空间，calloc不仅申请空间并且具有初始化功能，而realloc是在已经申请的空间基础上进行扩建或减小。

C++内存管理方式

C++使用new和delete操作符进行内存管理。

下面看一段代码了解一下new和delete的使用方法：

#include<iostream>
using namespace std;
class A
{public:
	A(int a = 0)
		:_a(0)
	{
	_a = a; 
	cout << "A(int a = 0)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}

	
private:
	int _a;
};
int main()
{	//malloc只开空间
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = (int*)malloc(sizeof(int) * 5);
	int* p3 = new int;
	int* p4 = new int[5] {1, 2, 3, 4, 5};
	//new在堆上开创空间+自定义类型自动调用构造函数初始化
	//delete 调用析构函数+释放空间给堆
	//一定要匹配使用！
	free(p1);
	free(p2);
	delete p3;
	delete[] p4;
	//delete p3;
	A* p5 = new A;
	A* p6 = new A[5];
	delete p5;
	delete[]p6;
    return 0; 
}

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

下面讲一下C和C++内存管理方式的不同：

对于内置类型：几乎相同。

对于自定义类型：new是先在堆上开空间，开完后再调用构造函数初始化，delete是先调用析构函数，然后再进行释放空间。

operator new与operator delete函数

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

下面看一些他们的源码：

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

通过源码我们发现operator new本质使用过调用malloc进行开空间的，申请成功返回，失败则进入用户设置的错误机制中，operator delete本质是用过调用free函数进行空间销毁的。

new的delete实现原理

内置类型

对于内置类型，malloc和new，delete和free几乎相同。

不同的是：new和delete申请和释放的是单个元素的空间，而new[]和delete[]申请和释放的是连续空间。

自定义类型

new的原理：

调用operator new申请空间

执行构造函数，进行初始化。

delete原理：

调用析构函数完成对象资源清理

调用operator delete释放空间

new T[N]原理：

调用operator []函数，operator new[]实际调用N次operator new函数创建N个空间

再在创建好的空间上执行N次构造函数

delete[]原理：

在空间上调用N次析构函数，完成所有对象中资源清理

调用operator []函数，operator delete[]函数实际调用operator deleteN次函数释放所有对象所在空间。

定位new表达式

new (place_address) type或者new (place_address) type(initializer-list) place_address必须是一个指针，initializer-list是类型的初始化列表。

使用场景：内存池。

//定位new表达式(placement - 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;
}

C和C++内存管理方式差异总结

1.malloc和free是函数，new和delete是操作符

2.malloc申请的空间不会初始化

3.malloc要计算要用的空间大小，new不用

4.malloc默认类型为void*，需要强转，new后面跟着空间类型，所以不用。

5.malloc申请失败，返回null，因此必须判空，而new不需要，new需要抛异常

6.申请自定义类型时，malloc和free只会申请和释放空间，而new和delete会调用构造函数和析构函数完成初始化和空间释放。

内存泄漏

堆内存泄漏(Heap leak)

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

系统资源泄漏

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