class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
class Stack
{
public:
	Stack()
	{
		cout << "Stack()" << endl;
		_a = new int[4];
		top = 0;
		capacity = 4;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		delete[]_a;
		top = 0;
		capacity = 0;
	}

private:
	int* _a;
	int top;
	int capacity;
};

int main()
{
		 //失败了抛异常
	int* p1 = (int*)operator new(sizeof(int*));

	// 失败返回nullptr
	int* p2 = (int*)malloc(sizeof(int*));
	if (p2 == nullptr)
	{
		perror("malloc fail");
	}

	 //申请空间 operator new -> 封装malloc
	 //调用构造函数
	A* p5 = new A;

	// 先调用析构函数
	// 再operator delete p5指向的空间
	// operator delete -> free
	delete p5;

	// 申请空间 operator new[] ->perator new-> 封装malloc
	// 调用10次构造函数
	A* p6 = new A[10];
	
	// 先调用10次析构函数
	// 再operator delete[] p6指向的空间
	delete[] p6;


	int* p7 = new int[10];
	free(p7);  // 正常释放

	A* p8 = new A;
	//free(p8); // 少调用的析构函数
	delete p8;
	//对于无空间开辟的少调用析构函数可以正常运行


	//Stack st;

	Stack* pts = new Stack;
	//free(pts);//这样就少调用了析构函数，会造成内存泄漏
	delete pts;


	return 0;
}

大家可以一一调试试验，验证上面的结论。

（4）总结

对于内置类型：

（5）定位new（了解）

class A
{
public:
 A(int a = 0)
 : _a(a)
 {
 cout << "A():" << this << endl;
 }
 ~A()
 {
 cout << "~A():" << this << endl;
 }
private:
 int _a;
};
// 定位new/replacement new
int main()
{
 // p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没
有执行
 A* p1 = (A*)malloc(sizeof(A));
 new(p1)A;  // 注意：如果A类的构造函数有参数时，此处需要传参
 p1->~A();
 free(p1);
 A* p2 = (A*)operator new(sizeof(A));
 new(p2)A(10);
 p2->~A();
 operator delete(p2);
  return 0;
}

（二）模板初阶

（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;
}
void Swap(char& left, char& right)
{
 char temp = left;
 left = right;
 right = temp;
}

但是我们发现，他们的基本思想和实现是差不多的，甚至除了变量的类型，其他都一样。那么我们可不可以使用一个“模具”来代替呢？？？

答案是可以的！我们会利用泛型编程来实现。

那么什么是泛型编程呢？

// 泛型编程 -- 模板

template<typename T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

（2）函数模板

函数模板格式：

样例参照交换函数的模板实现。

2.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);
 
 Add(a1,d2);
 
}

其中Add(a1,d2)无法通过编译。因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
 通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，
 编译器无法确定此处到底该将T确定为int 或者 double类型而报错
 注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅。

我们可以采用两种处理方式：

•  1. 用户自己来强制转化 ，如Add(a, (int)d);
• 2. 使用显式实例化

2.2、显式实例化

我们上面的两种处理方式中提到了显式实例化，那么如何实现呢？

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

template<class T1, class T2, ..., class Tn>
class 类模板名
{
 // 类内成员定义
}; 
// 动态顺序表
// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
template<class T>
class Vector
{ 
public :
 Vector(size_t capacity = 10)
 : _pData(new T[capacity])
 , _size(0)
 , _capacity(capacity)
 {}
 
 // 使用析构函数演示：在类中声明，在类外定义。
 ~Vector();
 
 void PushBack(const T& data)；
 void PopBack()；
 // ...
 
 size_t Size() {return _size;}
 
 T& operator[](size_t pos)


 {
 assert(pos < _size);
 return _pData[pos];
 }
 
private:
 T* _pData;
 size_t _size;
 size_t _capacity;
};

// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template <class T>
Vector<T>::~Vector()
{
 if(_pData)
 delete[] _pData;
 _size = _capacity = 0;
}

// Vector类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;