模板 ---模板进阶

预学先知

模板一般分为函数模板和类模板

1.函数模板

#include<iostream>
#include<cstdio>
using namespace std;

template<class T>
void Swap(T& a, T& b) {
	T t = a;
	a = b;
	b = t;
}

int main() {
	int a1 = 1, a2 = 2;
	Swap(a1, a2);
	cout << a1 << " " << a2 << endl;

	double b1 = 1, b2 = 2;
	Swap(b1, b2);
	cout << b1 << " " << b2 << endl;

	char c1 = 'z', c2 = 'k';
	Swap(c1, c2);
	cout << c1 << " " << c2 << endl;

	return 0;
}

auto跟泛型的区别：
auto初始化后面一定要跟一个值，不能作函数参数的值

两个不同类型的变量相加

#include<iostream>
#include<cstdio>
using namespace std;

template<class T>
T Add(const T& a,const T& b) {
	return a + b;
}

int main() {
	int a1 = 1, a2 = 2;
	Add(a1, a2);

	double b1 = 1.1, b2 = 2.2;
	Add(b1, b2);


	//想要使两种不同类型的变量相加
	//方法一，强转
	Add((double)a1, b2);
	//方法二，显示实例化,规定就是某种类型
	Add<int>(a1, b1);
	Add<double>(a1, b1);


	return 0;
}

2 .当函数模板和普通函数同时出现时候，会调用谁？
会调用普通函数，不会调函数模板

类模板

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

template<class T>
class Stack {
public:
	Stack(int capacity = 4)
		:_size(0),
		_capacity = capacity
	{
		_a = new T[capacity];
	}

	~Stack() {
		delete[] _a;
		_a = nullptr;
		_size = _capacity = 0;
	}
	void Push(const T& x);
private:
	T* _a;
	int _capacity;
	int _size;
};

template<class T>
void Stack<T>::Push(const T& x) {

}

int main() {
	Stack<int> s1;
	Stack<double> s2;
	Stack<char> s3;
	Stack<int*> s4;

	s1.Push(1);
	s1.Push(2);
	s1.Push(3);

	return 0;
}

就是一个模具

3. 模板进阶

模板进阶：
非类型模板参数 – 常量， 写在template当中，只能是整形（double ,string都是不行的），可以给缺省参数（从右往左，而且必须是连续的）
array定长数组，没啥用，但他的优势是可以查到数组越界，底层是一个operator[]的断言检查

函数模板–参数匹配
有现成吃现成，没有的话点外卖
显示实例化，专用化，也叫特化
在函数模板里面这种特化很鸡肋

类模板的特化
全特化，偏特化（半特化），指针，引用都可以特化
特化是对参数进一步的限制
非类型模板参数也是可以特化的

#include<iostream>
#include<cstdio>
#include<stdlib.h>

using namespace std;

template<class T1, class T2>
class Data
{
public:
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

//全特化
template<>
class Data<int,char>
{
public:
	Data() { cout << "Data<int, char>" << endl; }
private:
};

//偏特化，半特化
template<class T1>
class Data < T1, char >
{
public:
	Data() { cout << "Data<T1, char>" << endl; }
private:
};

template<class T1, class T2>
class Data<T1*,T2*>
{
public:
	Data() { cout << "Data<T1*, T2*>" << endl; }
private:
};

template<class T1, class T2>
class Data<T1&, T2*>
{
public:
	Data() { cout << "Data<T1&, T2*>" << endl; }
private:
};

//非类型模板参数
template<size_t N>
class A
{
public:
	A(){ cout << "A<N>" << endl; }
};

//非类型模板参数也是可以特化的
template<>
class A<10>
{
public:
	A() { cout << "A<10>" << endl; }
};

int main()
{
	Data<int, int> d1;
	Data<int, char> d2;
	Data<double,char> d3;
	Data<int*, int*> d4;
	Data<int&, int*> d5;
	A<10> a;
	A<50> b;
	return 0;
}

模板的分离编译
链接错误：语法过了，链接的时候找不到
Linux下为例，比如说有三个文件，vector.h vector.cpp test.cpp

编译链接的步骤
1.预处理（预编译） – 头文件展开/条件编译/去掉注释/宏替换
生成 vector.i test.i
2.编译 – 检查语法问题，如果没有问题的话，生成汇编代码
生成 vector.s test.s
3.汇编 – 将汇编代码变成机器二进制码
生成 vector.o test.o
4.链接
生成一个a.out

不处理，没有实例化的话，没有办法生成汇编代码class T
声明和定义的地方是分开的，没有定义就找不出地址call _(?), 定义的时候不知道要变成什么
链接之前是不会交互的
解决方案一：只能通过显示实例化的方式，写一个必须要实例化一个，这样写是不好的
解决方案一：模板声明和定义放一起，省去了链接的过程，这样头文件展开时，直接有模板的定义和实例化
保密：动静态库

模板总结：
优点：复用代码，增强代码灵活性
缺点：代码膨胀（实例化多份,看起来100行编译出来1000行），导致编译时间变长;出现模板编译错误时，错误信息会很凌乱