c++动态管理

---

前言

本文内容主要是弄完c++动态分配的问题。
本文主要从以下几个方面进行学习：
1.new/new[]和delete/delete[]的底层实现
2.new/delete和malloc/free的区别
3.内存泄露问题
以及常见面试题

---

一、new/new[]和delete/delete[]是什么？

查阅资料，发现new/new[]和delete/delete[]是操作符，是C++用来实现动态内存管理的操作符；而malloc和free是函数。此时发现是不是和心里想的不一样啊，为了解决这个疑惑，不得不把new/new[]和delete/delete[]底层实现拿出来一看究竟

底层实现原理

new在底层调用operator new全局函数来申请空间
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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

delete在底层通过operator 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) _free_dbg(p, _NORMAL_BLOCK)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

通过这两个全局函数的实现，知道了operator new 实际是通过malloc来申请空间的，operator delete实际是通过free来释放空间的；

虽然知道了new/delete实际是通过malloc/free实现的，但是在不同类型上，它们的处置还是有差别的：

1. 内置类型：
   如果申请的是内置类型的空间，new和malloc，delete和free基本类似；
   不同之处：
   new在申请空间失败时会抛异常；
   malloc在申请空间失败时会返回NULL；

2. 自定义类型：
   new的原理：
   （1）调用operator new函数申请空间；
   （2）调用构造函数，完成对象的构造
   delete的原理：
   （1）调用析构函数，完成对象中资源的清理工作
   （2）调用operator delete函数释放对象的空间
   new[N]的原理：
   （1）调用operator new[]函数，实际在operator new[]中调用operator new函数完成N个对象空间的申请
   看下列源码便知：

void *__CRTDECL operator new(size_t) /*_THROW1(std::bad_alloc)*/;

void * operator new[]( size_t cb )
{
    void *res = operator new(cb);

    RTCCALLBACK(_RTC_Allocate_hook, (res, cb, 0));

    return res;
}
1
2
3
4
5
6
7
8
9
10

（2）调用N次构造函数

delete[N]的原理：
（1）调用N次析构函数，完成N个对象中资源的清理
（2）调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放N个对象空间

二、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在释放空间前会调用析构函数完成空间中资源的清理

三、内存泄露

动态申请的内存，不使用了，又不主动释放，就存在内存泄漏。
知道了内存泄露问题的病因所在，我们不仅疑惑内存泄露有什么危害呢，以及怎么避免呢

内存泄漏的危害

1.出现内存泄漏的进程正常结束，进程结束时这些内存会还给系统，不会有什么大伤害。
2.出现内存泄漏的进程非正常结束，比如僵尸进程。危害很大，系统会越来越慢，甚至卡死宕机。
3.需要长期运行的程序出现内存泄漏。危害很大，系统会越来越慢，甚至卡死宕机。

如何避免内存泄漏

1.养成良好的编码规范，申请的内存空间记着匹配的去释放。
2.事前预防：如使用智能指针等。
3.事后查错：如泄漏检测工具

四、常见面试题

请设计一个类，该类只能在堆上创建对象
思路：
将类的构造函数,拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。提供一个静态的成员函数，该静态成员函数完成堆对象的创建。
代码如下：

class HeapOnly{
　　public:
　　　　static HeapOnly* CreateObject()
　　　　{
　　　　　　return new HeapOnly;
　　　　}

　　private:
　　　　HeapOnly(){}
　　　　//C++98
　　　　//1.只声明,不实现。因为实现可能会很麻烦,而你本身不需要   
　　　  //2.声明成私有
 　　　 HeapOnly(const HeapOnly&)；
        
　　　　// or            
　　　　// C++11        　　　　HeapOnly(const HeapOnly&) = delete;  
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

请设计一个类,该类只能在栈上创建对象
思路：
只能在栈上创建对象，即不能在堆上创建，因此只要将new的功能屏蔽掉即可，即屏蔽掉operator new和定位new表达式，注意：屏蔽了operator new，实际也将定位new屏蔽掉　
代码如下：

class StackOnly{
       public:
            StackOnly(){}

       private:
            void* operator new(size_t size);
            void* operator delete(void* p);
};
1
2
3
4
5
6
7
8

推荐一个零声学院免费公开课程，个人觉得老师讲得不错，
分享给大家：[Linux，Nginx，ZeroMQ，MySQL，Redis，
fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，
TCP/IP，协程，DPDK等技术内容，点击立即学习:服务器课程