【c/c++】内存管理

1.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";
 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.代码段

globalVal在哪里？  数据段
staticGlobalVar在哪里？数据段
staticVar在哪里？数据段
localVar在哪里?  栈
num1在哪里？栈


char2在哪里?栈
*char2在哪里？栈
pchar3在哪里？栈
*pchar3在哪里？代码段
ptr1在哪里？栈
*ptr1在哪里？堆

2.填空题：

sizeof(num1) =40
sizeof(char2)=5
strlen(char2)=4
sizeof(pChar3)=4/8
strlen(pChar3)=4
sizeof(ptr1)=4/8
sizeof(ptr2)=4/8

指针的4/8与进程地址空间有关系。
指针的本质是内存字节的编号。
32位malloc最大不超过3G大概就2G。
要超过3G，就换成64位。
一般栈就十几个M。
高一G内核
低三G？？（栈堆之类）
32位（2的32次方）与64位（2的64次方）跟进程有关系。
进程由编译器控制，编译器由人控制。

说明：

1. 栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共
享内存，做进程间通信。（现 在只需要了解一下）
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段--存储全局数据和静态数据。(c语言叫做静态数据区）
5. 代码段--可执行的代码/只读常量。（正文或常量区
不是自己的代码，是编译后二进制指令。）

2.C语言中动态内存管理方式malloc/calloc/realloc与free

详细请看：https://blog.csdn.net/weixin_41892460/article/details/82666228

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

3.C++内存管理方式

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

3.1new/delete操作内置类型

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

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

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

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

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

3.2new和delete操作自定义类型

class Test
{
public:
 Test()
 : _data(0)
 {
 cout<<"Test():"<<this<<endl;
 }
 ~Test()
 {
 cout<<"~Test():"<<this<<endl;
 }

private:
 int _data;
};
void Test2()
{
 // 申请单个Test类型的空间
 Test* p1 = (Test*)malloc(sizeof(Test));
 free(p1);

 // 申请10个Test类型的空间
 Test* p2 = (Test*)malloc(sizoef(Test) * 10);
 free(p2);
}
void Test2()
{
 // 申请单个Test类型的对象
 Test* p1 = new Test;
 delete p1;

 // 申请10个Test类型的对象
 Test* p2 = new Test[10];
 delete[] p2;
}

new：
内置内型 ： malloc和new效果一样。
自定义类型： malloc与new不一样。
c++建议用new。
new对于自定义类型，不仅开空间并且调构造函数初始化。
而malloc只负责开空间。
注意匹配：malloc匹配free;new匹配delect。

delete:
对于内置类型，delect与free差不多；对于自定义类型，delect先析构，再释放空间。
注意匹配：new匹配delect；malloc匹配free。

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

4.operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new和operator delete是系统提供的全局变量，new在底层调用operator new全局函数来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。delete在底层通过operator delete 全局函数来释放空间，而operator delete最终也是通过free来释放空间的。

注意：operator new和operator delete用户也可以自己实现，用户实现时即可实现成全局函数，也可实现成 类的成员函数，但是一般情况下不需要实现，除非有特殊需求。比如需要跟踪内存的申请与释放时。

5.new和delect的实现原理

5.1内置类型

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

5.2自定义类型

• new的原理
  1.调用operator new函数申请空间

内置类型

new int  ==》 operator new开空间 ==》 malloc  ==》 构造（失败抛异常）抛异常是为了复合c++的规范。失败就抛异常。

malloc int ==》 malloc （失败返回NULL）


int在c++有构造，为了兼容c++。

2.在申请的空间上执行构造函数，完成对象的构造

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

内置类型

new int  ==》 operator new开空间 ==》 malloc  ==》 构造（失败抛异常）抛异常是为了复合c++的规范。失败就抛异常。

malloc int ==》 malloc （失败返回NULL）


int在c++有构造，为了兼容c++。

6.定位new表达式（placement-new）

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

new (place_address) type或者new (place_address) type(initializer-list) 

使用场景：
定位new表达式在实际中一般是配合内存池（池化技术：减少内存碎片可以提高效率。）使用。因为内存池分配出的内存没有初始化，所以如果是自定义 类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

class Test
{
public:
 Test()
 : _data(0)
 {
 cout<<"Test():"<<this<<endl;
 }
 ~Test()



 {
 cout<<"~Test():"<<this<<endl;
 }

private:
 int _data;
};
void Test()
{
 // pt现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
 Test* pt = (Test*)malloc(sizeof(Test));

 new(pt) Test; // 注意：如果Test类的构造函数有参数时，此处需要传参
}


// Test* pt = (Test*)malloc(sizeof(Test));

 new(pt) Test; 
等价于：Test* pt = new Test

7.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可以，new在申请空间后会调用构造函数完成对象的构造，delete在释放空间前会调用析构函数
完成空间中资源的清理
7. malloc申请的空间一定在堆上，new不一定，因为operator new函数可以重新实现
因为operator new可以重载导致可能在栈上开辟
8. new/delete比malloc和free的效率稍微低点，因为new/delete的底层封装了malloc/free

8.内存泄漏

1）什么是内存泄漏

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

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;
 }

2）内存泄漏分类

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

• 堆内存泄漏(Heap leak)
  堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存， 用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那 么以后这部分空间将无法再被使用，就会产生Heap Leak。
• 系统资源泄漏 指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统 资源的浪费，严重可导致系统效能减少，系统执行不稳定。

3）如何避免内存泄漏

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

9.小试牛刀

1）设计一个类，该类只能在堆上创建

思想
1 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
2 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建
代码实现

#include<iostream>
#include<stdlib.h>
using namespace std;






class HeapType
{
public:
	static HeapType* GetHeapObj()
	{
		return new HeapType;
	}

private:
	HeapType()
	{}
	//构造函数：
	// 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要
	// 2.声明成私有
	

	//防止拷贝
	HeapType(const HeapType& ht);
	

};

//HeapType obj2;//不可以因为构造函数私有
//HeapType::HeapType(const HeapType& ht)//拷贝函数也不行
//{}
//
int main()
{
	HeapType* p1 = HeapType::GetHeapObj();
	/*HeapType obj1;*///不可以
	/*HeapType obj3(*p1);*///不可以
	system("pause");
	return 0;
}

2）设计一个类，该类智能在栈上创建

方法一（推荐该方法）
1 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
2 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

//推荐方法
class StackType
{
public:
	static StackType GetStackObj()
	{
		//return StackType();
		StackType obj;
		return obj;
	}

	void Print()
	{
		cout << "StackType::Print()" <<this<< endl;
	}
private:
	StackType()
	{}
};

//StackType obj;//不可以

int main()
{
	StackType::GetStackObj().Print();
	StackType obj = StackType::GetStackObj();
	obj.Print();

	/*StackType* p = new StackType;*///不可以
	system("pause");
	return 0;
}

方法二（不推荐）
思路：只能在栈上创建对象，即不能在堆上创建，因此只要将new的功能屏蔽掉即可，即屏蔽掉operator new和定 位new表达式，注意：屏蔽了operator new，实际也将定位new屏蔽掉。
代码实现
不影响别的对象的new，但它有死穴，比如数据段中 ;eg StackType obj2; main中的static StackOnly obj3;也可以堆上创建。所以不推荐该方法，但这也是一种解题思路。

class StackType
{
public:
	StackType()
	{}

	void Print()
	{
		cout << "StackType::Print()" << endl;
	}

private:
	void* operator new(size_t n) = delete;
	void operator delete(void* p) = delete;
};

StackType obj2;//可以创建所以不推荐

int main()
{
	StackType obj1;//可以
	static StackType obj3;//可以
	//StackType* pobj2 = new StackType; // 只有这个不可以


	system("pause");
	return 0;
}