C/C++内存管理

目录

一、C/C++中程序内存区域划分

 二、C语言和C++中的动态内存管理方式

 三、operator new与operator delete函数

 四、new和delete的实现原理

五、 定位new表达式(placement-new)

六、malloc/free和new/delete的区别

七、内存泄漏

 八、内存泄漏的分类

九 、如何一次在堆上申请4G内存

---

一、C/C++中程序内存区域划分

 牛刀小试:

 选项: A.栈 B.堆 C.数据段 D.代码段
1.globalVar在哪里？_C___
  全局，在静态区
 2.staticGlobalVar在哪里？_C___
  static在静态区
 3.staticVar在哪里？__C__  
  static在静态区
 4.localVar在哪里？__A__
 局部，在栈
 5.num1 在哪里？_A___
 局部变量，在栈中
 6.char2在哪里？__A__
局部变量，在栈中

7.*char2在哪里？_A__
char2是一个字符数组,然后将字符常量"abcd"赋值给char2,char2会在栈上开辟5个空间来存储，数组解引用，表示的是首元素，首元素地址也在栈中

8.pChar3在哪里？_A___
局部变量在栈中

9.*pChar3在哪里？__D__
pchar3中存在的是常量字符串，储存在常量区，所以*pchar3是在常量区

10.ptr1在哪里？__A__
局部变量在栈中

11.*ptr1在哪里？_B___
ptr1中存放的是动态开辟的，*ptr1是在堆中的

//32为程序下

sizeof ( num1 ) = __40__ ;

//4*10,但如果是int num[] = {1,2,3,4};则是16

sizeof ( char2 ) = _5___ ;

//空间大小,abcd/0,5个空间

strlen ( char2 ) = _4___ ;

//长度 ,/0终止，是4B

sizeof ( pChar3 ) = _4___ ;

//指针4B

strlen ( pChar3 ) = __4__ ;

//长度4B

sizeof ( ptr1 ) = _4___ ;

//指针4B

 二、C语言和C++中的动态内存管理方式

C语言中的动态内存管理方式:

就是我们常见的malloc,calloc,而calloc就相当于malloc+memset，会对开辟的动态内存进行初始化,realloc会进行增容,一种就是后面直接增容,另一种就是可能因为后面空间不够,重新开辟一块连续空间将之前的拷贝过来,然后以达到增容的效果

C++中的动态内存管理方式:

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

 

 所以可以看出,C与C++对于内置类型只有用法上的区别,但没有本质的区别

但是真的C和C++真的是没有区别的吗？当然不是

对于自定类型,C语言的malloc只会做纯粹的开辟空间的操作

而C++的new不仅会在堆上申请对象空间,而且会去调用他的构造函数对开辟的空间进行初始化,C语言的free也只会释放空间,而C++的delete会去调用他的析构函数，并且释放堆上的空间

 注意：一定要malloc free 和 new delete /new[ ] delete[ ]匹配使用，否则可能会崩溃

 C++的new和C语言malloc的区别真的就只有如此吗？我还是那句话，当然不是

面向对象的语言,处理错误的方式一般是抛异常,C++中也要求出错抛异常--try catch

面向过程的语言,处理错误的方式是返回错误码解决

 

 总结:C++提出new和delete,主要解决的是俩个问题

1.在对自定义类型对象进行自动申请的时候,new和delete会去调用构造函数和析构函数进行初始化和清理,new:申请空间+调用构造函数初始化,delete:调用析构函数清理对象中的资源,再释放空间

2.new失败后会抛异常,这样才符合面向对象语言的出错处理机制

3.delete和free一般不会失败,如果失败了,都是释放空间上存在越界或者释放指针的位置不对

 三、operator new与operator delete函数

class Stack
{
public:
	Stack(int capacity = 4)
		:_top(0)
		, _capacity(capacity)
	{
		_a = new int[capacity];
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
	
	Stack* pst1 = (Stack*)operator new(sizeof(Stack));//和malloc用法是一样的，只是开空间,不会初始化
	Stack* pst2 = new Stack;
	operator delete(pst1);
	delete(pst2);
	return 0;
}

 从上述可以看出operator new只是开辟了空间,但是没有进行初始化,那么也就是与malloc的作用是相同的,而new既进行了开辟空间也调用了构造函数进行初始化,而operator delete也只是释放了空间,并没有对空间进行清理,与之相比delete会先调用析构函数,然后再进行释放空间

其实new 和 delete 是用户进行 动态内存申请和释放的操作符 ， operator new 和 operator delete 是系统提供的全局函数 ， new 在底层调用 operator new 全局函数来申请空间， delete 在底层通过 operator delete 全局函数来释放空间。
正如下面的俩个全局函数底层代码: operator new 实际也是通过 malloc 来申请空间 ，如果 malloc 申请空间 成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异 常。 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);
}
/*
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)

总的来说,也就是new和delete分别去调用他们的全局函数operator new和operator delete，然后operator new和operator delete其实又是对malloc和free的封装,说到底还是去堆上去申请和释放空间,这样就好比,小和尚想要喝水,只有山下有水,每次喝水都要跑到山下,这样是否会觉得有些麻烦呢？

正因为这个原因,我们为何不接个自来水或者把水每次挑到山上,想和就喝呢？

因此,我们引入了operator new与operator delete的类专属重载,这就不需要我们每次去堆上去申请和释放空间了
总结: new = operator new + 调用构造函数
         delete = operator delete + 调用析构函数

struct ListNode
{
     ListNode* _next;
     ListNode* _prev;
     int _data;
  	//new会去调用全局的operator new，这是我们自己实现的一个operator new重载，就不会去调用全局的
    void* operator new(size_t n)
    {
      void* p = nullptr;
      p = allocator<ListNode>().allocate(1);//STL中的内存池---空间配置器
      cout << "memory pool allocate" << endl;
      return p;
    }
    void operator delete(void* p)
   {
     allocator<ListNode>().deallocate((ListNode*)p, 1);
     cout << "memory pool deallocate" << endl;
   }
};
class List
{
public:
   List()
   {
   _head = new ListNode;
   _head->_next = _head;
   _head->_prev = _head;
   }
   ~List()
   {
   ListNode* cur = _head->_next;
   while (cur != _head)
   {
   ListNode* next = cur->_next;
   delete cur;
   cur = next;
   }
   delete _head;
   _head = nullptr;
   }
   void PushBack(int val)
	{
		ListNode* newnode = new ListNode(val);//因为有了重载,new就不会去调用全局的operator new
		ListNode* tail = _head->_prev;
		tail->_next = newnode;
		newnode->_prev = tail;
		newnode->_next = _head;
		_head->_prev = newnode;
	}

private:
 	ListNode* _head;
};
int main()
{
	List L;
  	L.PushBack(1);
	L.PushBack(2);
	L.PushBack(3);
 	return 0; 
}

 四、new和delete的实现原理

内置类型：

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

自定义类型 :

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

五、 定位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)
	{

	}
	~A()
	{

	}

private:
	int _a;
};

int main()
{
	//malloc只是开辟空间不会进行初始化
	A* p1 = (A*)malloc(sizeof(A));
	//构造函数不可以显性调用,所以可以使用定位new进行初始化
	//new(p1)A;//使用全省参数
	new(p1)A(1);//不使用全省参数

	A* p2 = new A(2);//会开辟空间+初始化
	delete p2;//清理+释放空间

	//等价于

	A* p3 = (A*)operator new(sizeof(A));//内存池分配内存,但不会初始化
	new(p3)A;

	//析构可以显性调用
	p3->~A();
	operator delete(p3);
}

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

七、内存泄漏

什么是内存泄漏：

动态申请的内存,不使用了,有没有主动释放,就存在内存泄漏

内存泄漏的危害：

(1)出现内存泄漏的进程正常结束,竭诚结束时这些内存会怀给系统,不会有什么危害

(2)出现内存泄漏的进程正常结束,比如僵尸进程,危害很大,系统会越来越慢,甚至卡死宕机

(3)需要长期运行的程序,出现内存泄漏,危害很大,系统会越来越慢,甚至卡死宕机,比如服务器程序

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

 八、内存泄漏的分类

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

堆内存泄漏(Heap leak)：

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

系统资源泄漏 ：

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

九 、如何一次在堆上申请4G内存