预学先知
模板一般分为函数模板和类模板
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行),导致编译时间变长;出现模板编译错误时,错误信息会很凌乱