内存管理&模板

一、C/C++内存管理

1、C/C++内存分布

#include<iostream>
using namespace std;

int globalVal = 1;//静态区
static int staticGlobalVal = 1;//静态区
int main()
{
	static int staticVal = 1;//静态区
	int localVal = 1;//栈

	int num1[10] = { 1,2,3,4 };//栈
	char char2[] = "abcd";//char2在栈，*char2也在栈
	const char* pChar3 = "abcd";//pChar3在栈，*pChar在常量区
	int* ptr1 = (int*)malloc(sizeof(int) * 4);//ptr1在栈，*ptr1在堆
	int* ptr2 = (int*)calloc(4, sizeof(int));
	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
	free(ptr1);
	free(ptr3);

	const int x = 10;//栈
	int y = 1;//栈
	cout << &x << endl;
	cout << &y << endl;
	cout << (void*)pChar3 << endl;//常量区
	return 0;
}

说明：
1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口
创建共享共享内存，做进程间通信。
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段--存储全局数据和静态数据。
5. 代码段--可执行的代码/只读常量。

2、C++内存管理方式

通过new和delete操作符进行动态内存管理。

2.1 new/delete操作内置类型

int main()
{
	int* ptr2 = (int*)calloc(4, sizeof(int));
	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);

	cout << ptr2 << endl;
	cout << ptr3 << endl;

	//动态申请一个int类型的空间
	int* ptr4 = new int;
	//动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
	//动态申请10个int类型的空间
	int* ptr6 = new int[10];
	int* ptr7 = new int[10]{1,2,3,4};

	delete ptr4;
	delete ptr5;
	delete[] ptr6;
	delete[] ptr7;
	return 0;
}

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

2.2 new/delete操作自定义类型

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

struct ListNode
{
	int _val;
	ListNode* _next;
	ListNode(int val=0)
		:_val(val)
		,_next(nullptr)
	{}
};

int main()
{
	//new/delete和malloc/free最大区别是：new/delete对于自定义类型除了会开辟空间，还会调用构造函数
	A* p1 = (A*)malloc(sizeof(A));
	free(p1);

	A* p2 = new A(1);
	delete p2;

	ListNode* n1 = new ListNode(1);
	ListNode* n2 = new ListNode(2);
	ListNode* n3 = new ListNode(3);
	ListNode* n4 = new ListNode(4);

	n1->_next = n2;
	n2->_next = n3;
	n3->_next = n4;
	n4->_next = nullptr;

	return 0;
}

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

3、operator new & operator delete函数

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

/*operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否
则抛异常。*/

void* CRTDECL operator new (size_t size) _THROW1(_STD bad_alloc)
{
	//分配空间
	void* p;
	while ((p = malloc(size)) == 0)
		if (_callnewh(size) == 0)
		{
			// 如果申请内存失败了，这里会抛出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)

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

4、new & delete实现原理

4.1 内置类型

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

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

5、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、函数模板格式

template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}

//函数模板
//针对任意类型的对象交换
template<typename T>
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

int main()
{
	int i = 0, j = 1;
	double x = 1.1, y = 2.2;
	Swap(i, j);
	Swap(x, y);
	return 0;
}

注意：typename是用来定义模板参数关键字，也可以使用class（不能使用struct代替class）

3、函数模板原理

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应
类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，
将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

4、函数模板实例化

使用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

4.1 隐式实例化

让编译器根据实参推演模板参数的实际类型

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10 .0, d2 = 20 .0;
	Add(a1, a2);
	Add(d1, d2);
	/*
	该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
	通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有
	一个T，编译器无法确定此处到底该将T确定为int 或者double类型而报错
	注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要
	背黑锅
	Add(a1 , d1);
	*/
	// 此时有两种处理方式：1 . 用户自己来强制转化2 . 使用显式实例化
	Add(a, (int)d);
	return 0;
}

4.2 显式实例化

在函数名后的<>中指定模板参数的实际类型

int main(void)
{
	int a = 10;
	double b = 20.0;
	// 显式实例化
	Add<int>(a, b);
	return 0;
}

如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

5、模板参数的匹配原则

1.一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。

// 专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
	return left + right;
}
void Test()
{
	Add(1, 2);       // 与非模板函数匹配，编译器不需要特化
	Add<int>(1, 2);  // 调用编译器特化的Add版本
}

2. 对于非模板函数和同名函数模板，如果其他条件相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板。

   // 专门处理int的加法函数
   int Add(int left, int right)
   {
   return left + right;
   }
   // 通用加法函数
   template<class T1, class T2>
   T1 Add(T1 left, T2 right)
   {
   return left + right;
   }
   void Test()
   {
   Add(1, 2);// 与非函数模板类型完全匹配，不需要函数模板实例化
   Add(1, 2.0);// 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
   }

3.模板函数不允许自动类型转换，但普通函数可以自动类型转换。

6、类模板

typedef double DataType;
namespace bit
{
	//类模板
	template<class T>
	class stack
	{
	public:
		stack(int n = 4)
			:_a(new T[n])
			, _top(0)
			, _capacity(n)
		{
			cout << "stack(int n=4)" << endl;
		}
		void push(const T& x)
		{
			_a[_top] = x;
			++_top;
		}
		~stack()
		{
			delete[] _a;
			_a = nullptr;
			_top = 0;
			_capacity = 0;
		}
	private:
		T* _a;
		int _top;
		int _capacity;
	};
}

int main()
{
	//显示实例化 
	bit::stack<int> st1;//int
	bit::stack<double> st2;//double

	st1.push(1);
	st1.push(2); 
	st1.push(3);
	st1.push(4);

	st1.push(1.1);
	st1.push(2.1);
	st1.push(3.1);
	st1.push(4.1);

	return 0;
}