C++内存管理+模板

---

一、C++内存管理

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

1. new和delete

(1)操作内置类型
代码如下：

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

（2）操作自定义类型

代码如下（示例）：

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	A* p3 = new A;
	delete p3;
	return 0;
}

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

如何对一块已有的空间初始化？

另外：new一个类对象和使用类名动态创建一个类对象有什么区别？
代码如下：

class Stack
{
public:
	Stack()
	{
		cout << "Stack()" << endl;
		_a = new int[4];
		_top = 0;
		_capacity = 4;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		delete[] _a;
		_top = _capacity=0;

	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st;
	Stack* pst = new Stack;
	//delete st;//不需要手动销毁，自动调用析构函数销毁
	cout<<pst<<endl;
	delete pst;//new出来的需要手动销毁
	return 0;
}

运行结果：
答案：
1.存储空间上不同。new出来的在堆上，直接定义的在栈上
2.栈上分配的在函数结束后会自己释放，堆上的要自己手工释放。

2. 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)
{
// try to allocate size bytes
void *p;
while ((p = malloc(size)) == 0)
比特就业课
通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果
malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施
就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
5. new和delete的实现原理
5.1 内置类型
     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;
}

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
new的原理：

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

二、模板

1.函数模板

先来看一段代码：

void Swap(int& left, int& right)
{
 int temp = left;
 left = right;
 right = temp;
}
void Swap(double& left, double& right)
{
 double temp = left;
 left = right;
 right = temp;
}
int main()
{
	int a = 1, b = 2;
	Swap(a, b);
	double c = 1.1, d = 2.22;
	Swap(c, d);
	return 0;
}

这是两个参数类型不同的交换函数，虽然可以自动识别类型，但参数类型不同，就要重新写一个函数，是否太麻烦了？如何解决？–模板
代码如下（示例）：

//泛型编程---模板
template<class T>
template<typename T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 1, b = 2;
	double c = 1.1, d = 2.22;
	Swap(c, d);
	Swap(a, b);
	return 0;
}

这样就更方便了，但注意你虽然写了一个函数，但所传参数类型不同时，调用的是不同的函数，你虽然只写了一个函数，但编译器根据参数类型帮你写了多个函数。
概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
函数模板格式
template<typename T1, typename T2,…,typename Tn>
返回值类型 函数名(参数列表){}
当所传的两个参数类型不同时，如何解决？
看以下代码：

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;
	//实参传递给形参，自动推演模板类型
	cout << Add(a1, a2) << endl;
	cout << Add(d1, d2)<< endl;
	//类型转换
	cout << Add(a1, (int)d1) << endl;
	cout << Add((double)a1, d1) << endl;
	//显示实例化
	cout << Add<int>(a1, d1) << endl;
	cout << Add<double>(a1, d1) << endl;
	return 0;
}

运行结果：

2.类模板

先看以下代码：

typedef double STDataType;
//typedef int STDataType;
class Stack
{
private:
	STDataType* _a;
	size_t _top;
	size_t _capacity;
};
int main()
{
	Stack st1;//int
	Stack st2;//double

	return 0;

因为参数类型不同，要写相似的多个类,如何解决这个问题？

template<class T>
class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = new T[capacity];
		_top = 0;
		_capacity = 0;
	}
	~Stack()
	{
		delete[] _a;
		_capacity = _top = 0;
	}
private:
	T* _a;
	size_t _top;
	size_t _capacity;
};
int main()
{
	Stack<int> st1;//int
	Stack<double> st2;//double
	return 0;
}

现在理解以下代码是不是就很容易了？

int main()
{
	vector<int> v;//实例化一份数据类型为int的vector
	for (size_t i = 0; i < v.size(); ++i)
	{
		cout << v[i] << " ";
	}
	cout << endl;
	return 0;
}

---