C++内存管理

最新推荐文章于 2024-05-20 15:29:54 发布

Happy__pomelo

最新推荐文章于 2024-05-20 15:29:54 发布

阅读量79

点赞数 1

文章标签： c++ c语言数据结构

本文链接：https://blog.csdn.net/Happyour_and_V/article/details/130324849

版权

1、内存分布

栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。
内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
堆用于程序运行时动态内存分配，堆是可以上增长的。
数据段--存储全局数据和静态数据。
代码段--可执行的代码/只读常量。

代码验证：

int g_unval;
int g_val = 100;

void test2()
{
    const char *s ="hello world";
    printf("code addr: %p\n", test1);
    printf("string rdonly addr: %p\n", s);
    printf("uninit addr: %p\n", &g_unval);
    printf("init addr: %p\n", &g_val);
    char *heap = (char*)malloc(10);
    char *heap1 = (char*)malloc(10);
    char *heap2 = (char*)malloc(10);
    char *heap3 = (char*)malloc(10);
    char *heap4 = (char*)malloc(10);

    printf("heap addr: %p\n", heap1);
    printf("heap addr: %p\n", heap2);
    printf("heap addr: %p\n", heap3);
    printf("heap addr: %p\n", heap4);

    printf("stack addr: %p\n", &s);
    printf("stack addr: %p\n", &heap);
    int a = 10;
    int b = 30;
    printf("stack addr: %p\n", &a);
    printf("stack addr: %p\n", &b);
	return;
}

从这段代码一一对比可以发现，变量的地址符合上图规则

代码段，存储着常量地址，处于最下面的地址，地址向上递增；

数据段，存储着全局变量、静态变量的地址，地址向上递增；

堆区，存储着使用malloc、new生成的变量，地址向上递增；

栈区，存储着变量名，比如main，test2（本实例用的test2），heap这个变量名等等

举个栗子：heap变量名是存储于栈区内的，但是该指针指向的是堆区内容

2、动态内存分配

malloc/calloc/realloc/free，这几个函数都是用于内存的动态分配的，接下来让我们看一下这段代码是否存在错误？

void Test ()
{
 int* p1 = (int*) malloc(sizeof(int));
 free(p1);
 
 int* p2 = (int*)calloc(4, sizeof (int));
 int* p3 = (int*)realloc(p2, sizeof(int)*10);

 free(p3 );
}

答案是没有错误，可能会有些小伙伴认为此处仅对p3进行了释放空间，没有堆p2进行空间释放，会造成内存泄漏，但是实际上真的是这样的吗？这里我们来扩展malloc/calloc/realloc的区别malloc/calloc/realloc的区别是什么？

malloc是直接在堆上面生成一片空间，不会初始化；

calloc与malloc一样，但他们之间的唯一区别就是，calloc会进行初始化，将值置0；

realloc的功能是在原有的地址基础之上，也就是意味着首地址没有变，再申请额外的连续的一片空间，此处需要注意的有两点，realloc可以对没有申请空间的变量名进行直接开辟空间，其原型是直接调用malloc，另一点是realloc如果开辟的空间此处不够，则会重新找一片空间足够的地方去开辟，在开辟之前会将之前的内容拷贝至新地址处（memcpy）原地址释放掉，然后再申请额外的空间。

看到这里，相信大家就知道了这三个函数的区别了，对于这段代码之所以不free（p2）相必也有点头绪了。在p3申请完空间，会有3种情况，1、原地址不变直接申请成功，在释放的时候p3与p2的首地址一样，因此只需要释放p3即可；2、原地址处空间不够，改变地址，再次期间p2已经释放，因此也不用释放p2；3、申请空间失败，直接抛异常。

3、C++内存管理

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。接下来我们就展开了解一下new与delete这两个新东西。

new与delete是什么呢？

他们是操作符，而不是函数。

使用方法;

类型指针变量名 = new 类型[个数] // [个数]这一块可以省略不写，默认申请一个空间

delete[] 变量名; // 如果释放对象不是数组形式的，则不用加[]，反之则必须加上，否则将会造成内存泄漏

先看代码：

void test5(void)
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;

	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);

	// 动态申请10个int类型的空间
	int* ptr6 = new int[3];

	delete ptr4;
	delete ptr5;
	delete[] ptr6;
}

可以看到new这种格式相对于malloc来说，看着简洁不少，那么在这段代码中，做了哪些事呢？

既然上面看到会进行调用默认的构造函数进行初始化，总不可能说一下理论就行了的，那么接下来我们来进行代码实践。


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

void test6(void)
{
	A* p1 = (A*)malloc(sizeof(A));
	free(p1);
	cout << "___________________" << endl;
	A* p2 = new A(1);
	delete p2;

}

验证成功，new进行了调用默认构造函数，delete调用了默认析构函数。如果没有默认的构造/析构函数则会报错，大家可以动手试一下，这里就不写没有默认构造/析构函数的代码了。

接下来我们来看一段更长的，加深一点难度

void test7(void)
{
	// 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);
	cout << "p4 -->" << *p4 << endl;
	delete p4;
	A* p5 = (A*)malloc(sizeof(A) * 10);
	A* p6 = new A[10];
	free(p5);
	delete[] p6;
}

需要注意的是，在这段代码里面，加了一段验证内置类型是否会初始化的语句，即验证p4是否会初始化

验证得知：内置类型并没有初始化，也就意味着，不会对内置类型初始化，只会对自定义类型进行初始化。

4、operator new 与operator delete 与free函数原型

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

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator 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;
}

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

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

这上面这些看着都是一堆不认识的代码，我们只需要关注3行代码，就可以看到，new的本质也是在调用malloc，delete本质是在调用free

5、new与delete实现原理

（1）内置类型：

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

new的原理：
- 调用operator new函数申请空间
- 在申请的空间上执行构造函数，完成对象的构造
new T[N]的原理
- 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
- 在申请的空间上执行N次构造函数
delete的原理：
- 在空间上执行析构函数，完成对象中资源的清理工作
- 调用operator delete函数释放对象的空间
delete[] 的原理
- 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
- 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

6、定位new

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

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

7、内存泄漏

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

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

void MemoryLeaks()
{
   // 1.内存申请了忘记释放
  int* p1 = (int*)malloc(sizeof(int));
  int* p2 = new int;
  
  // 2.异常安全问题
  int* p3 = new int[10];
  
  Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
  
  delete[] p3;
}

内存泄漏主要原因是进行了堆空间申请，使用完之后忘记了释放该内存，然而该内存已经不会再使用了，但是也不能被其他变量所使用，因此造成了内存泄漏。

如何避免内存泄漏

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

Happy__pomelo

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
C++内存管理

realloc的功能是在原有的地址基础之上，也就是意味着首地址没有变，再申请额外的连续的一片空间，此处需要注意的有两点，realloc可以对没有申请空间的变量名进行直接开辟空间，其原型是直接调用malloc，另一点是realloc如果开辟的空间此处不够，则会重新找一片空间足够的地方去开辟，在开辟之前会将之前的内容拷贝至新地址处（memcpy）原地址释放掉，然后再申请额外的空间。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
复制链接

扫一扫