c/c++《内存管理》完整版 主要包括：《c/c++的内存分布》《c/c++的内存管理》《new和delete的实现原理》《常见面试题 & 内存泄漏等》

一，c/c++的内存分布
故名：我们由题目就可以看出这是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.代码段
globalVar在哪里？____ staticGlobalVar在哪里？____
staticVar在哪里？____ localVar在哪里？____
num1 在哪里？____
char2在哪里？____ *char2在哪里？___
pChar3在哪里？____ *pChar3在哪里？____
ptr1在哪里？____ *ptr1在哪里？____
2. 填空题：
sizeof(num1) = ____;
sizeof(char2) = ____; strlen(char2) = ____;
sizeof(pChar3) = ____; strlen(pChar3) = ____;
sizeof(ptr1) = ____;

我们可以由上面的例子来了解c/c++内部的内存分布。
根据我们的了解，我们的回答答案是：c c c c a a d a d a b(在堆上面是动态开辟)
第二，填空题： 40 5 4 4/8 4 4/8 【我相信大家在疑惑为什么是4/8，是因为在32位和64位上面是不一样的】

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

二. C语言中动态内存管理方式
1.malloc /calloc /ralloc 和 free;
下面我们可以看这样一段代码；

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

首先，毫无疑问，我们可以了解到：
这三点都是开辟空间的，他们是怎么样开辟空间的呢？

malloc在内存的动态存储区中分配一块长度为size字节的连续区域，返回该区域的地址。
calloc与malloc类似，参数size为申请地址的单元元素长度，nmemb是参数个数。
realloc是给一个已经分配了的地址的指针重新分配空间，参数p为原有空间的地址，newsize是重新申请的地址空间

不同点（区别）：
malloc不能初始化所分配的内存空间，需要用memset初始化。如果这块空间被初始化过，则可能遗留各种各样的数据。
calloc会将所分配的空间中的每一位都初始化为0。
realloc可以对给定的指针所指向的空间进行扩大或缩小，原有的内存中内容将保持不变。realloc并不保存新的内存空间和原来的内存空间保持同一内存地址，返回的指针可能指向新的地址。

最后在使用完了之后，一定要将使用开辟过后的代码 free掉；防止内存泄漏。

三. c++的内存管理

C语言的管理内存方式在c++中同样是适用，但是比较麻烦，所以c++又提出了自己的内存管理方式：new 和 delete

3.1 new / delete 操作的内置类型

void Test()
{
// 动态申请一个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和delete操作符，申请和释放连续的空间，使用new[]和delete[]

3.2 new和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(sizeof(Test) * 10);
	free(p2);
}
void Test3()
{
	// 申请单个Test类型的对象
	Test* p1 = new Test;
	delete p1;
	// 申请10个Test类型的对象
	Test* p2 = new Test[10];
	delete[] p2;
}
int main()
{
	Test3();
	return 0;
}

在这里我们没有打印，显示出来，我们由调试的层面看一下，下面我们看一调试的图片：

这个是C语言中的怎么动态开辟和释放。

这是c++中的使用，我们可以看到它不仅仅是释放，而且初始化。

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

四。operator new与operator delete函数

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

下面，我们就由链表节点的ListNode 来看一下的opertaor new 和 operator delete申请和释放。

struct ListNode
{
	ListNode* _head;
    ListNode* _prev;
	ListNode* _next;
	int _data;
void* operator new(size_t n)
	{
		void* p = nullptr;
		p = allocator<ListNode>().allocate(1);          //分配内存；
		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;
	}
private:
	ListNode* _head;
};
int main()
{
	List l;
	List l1;
   return 0;
}

下面我们再看执行的程序：

由程序就看以看出，执行一次程序，调用一次构造函数和一次析构函数，并且释放。

五。new和delete的实现原理
1 内置类型

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

2 自定义类型

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的定义表达式进行显示调构造函数进行初始化。

上面这是定义，咱们看一下下面的代码：
**

#include<malloc.h>
#include<stdlib.h>
class Test
{
public:
	Test()
		: _data(0)
	{
		cout << "Test():" << this << endl;
	}
	~Test()
	{
		cout << "~Test():" << this << endl;
	}
private:
	int _data;
};
void Test()
{
	// pt现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	int* pt = (int*)malloc(sizeof(int));
	new(pt)int(3); // 注意：如果Test类的构造函数有参数时，此处需要传参
}
int main()
{
	Test();
	return 0;
}

下面我们由内存哪里看一下调试

七. 常见面试题

1 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在释放空间前会调用析构函数完成空间中资源的清理
7. new/delete比malloc和free的效率稍微低点，因为new/delete的底层封装了malloc/free

2请设计一个类，该类只能在堆上创建对象

class HeapOnly
{
public:
	static HeapOnly* CreateObject()
	{
		return new HeapOnly;
	}
private:
	HeapOnly() {}
	// C++98
	// 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要
	// 2.声明成私有
	HeapOnly(const HeapOnly& ); // 只声明，有漏洞，copy是在栈上面，但是这里是只实现堆上面，
	                             // 因为不管是类里面共有还是在类外面，都可以调用，除非是在私有。
		// or
		// C++11
	HeapOnly(const HeapOnly&) = delete;  // 这是c++11中给的类型，delete是删除函数。
};

int main()
{
	HeapOnly* p1 = HeapOnly::CreateObject();
	//HeapOnly copy(* p1 );    //这个一般不要实现。
	return 0;
}

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

3.请设计一个类，该类只能在栈上创建对象
**

class StackOnly
{
public:
static StackOnly CreateObject()
{
return StackOnly();
}
private:
StackOnly() {}
};

只能在栈上创建对象，即不能在堆上创建，因此只要将new的功能屏蔽掉即可，即屏蔽掉operator new和定 位new表达式，注意：屏蔽了operator new，实际也将定位new屏蔽掉。

或者是下面的表示方法：

class StackOnly
{
public:
StackOnly() {}
private:
void* operator new(size_t size);
void operator delete(void* p);
};

4.单例模式

设计模式：
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

class  ConfigSingleton
{
public:
	static ConfigSingleton* GetInstance()
	{
		return  &_sinst;  //1.返回指针；
	}
	//static ConfigSingleton& GetInstance()
	//{
	//	return  _sinst;  //2.返回引用；
	//}
    
void  Print()
{
		cout << _ip << endl;
		cout << _port << endl;
	}
private:
	ConfigSingleton(const char* ip , int port)
		:_ip(ip)
		, _port(port) //获取对象
	{
}
	const char* _ip;
	int _port;
	static ConfigSingleton _sinst;   //静态的相当于全局的；
};
ConfigSingleton ConfigSingleton::_sinst("2018.12.3", 80);
int main()
{
	ConfigSingleton::GetInstance()->Print();
	return 0;
}

这就是单例模式。

5.内存泄漏

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

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

int  main()
{
	MemoryLeaks();
	return 0;
}

在这段代码实现中，你会发现，vs并不会报错，而且也没有发现内存泄漏，但是，实际上面，它是由内存泄漏的，只不过是因为，如今的计算机的内存都比较大了，如果由任务管理器里面就可以直观的看到。

6.内存泄漏分类

堆内存泄漏(Heap leak)

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

系统资源泄漏

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

7.如何避免内存泄漏

解决方案分为两种：
1、事前预防型。如智能指针等。
2、事后查错型。如泄漏检测工具。

8.如何一次性在堆上面开辟一个4G的内存？

首先，我们要知道，在vs中，一般我们使用的是 x32 位机器，他的最大内存为4G，我们要开出4G，肯定是不可以的，因为系统还要占一点点，那么我们应该如何开辟，这里，只要我们把 x32位 改为 X64 那么我们就可以开出来。下面附上代码：

int main()
{
int * p = (int)malloc(0xffffffff);
cout << p << endl;
return 0;
}*