C++之模板

模板主要应用于泛型编程，现在主要就是非常火的STL（标准模板库），对于公司项目来说利用模板的可能性不大，一般一个项目是无法达到模板这个要求的。

一、函数模板

函数模板的要求是：

1、函数名一致

2、参数个数一致

3、函数体一致

4、参数类型不同

函数模板的格式:

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

举个例子：

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

int main() {
int a = 5;
int b = 3;
cout << "a = " << a << ", b = " << b << endl;
Swap(a, b);
cout << "a = " << a << ", b = " << b << endl;

double c = 5.6;
double d = 3.2;
cout << "c = " << c << ", d = " << d << endl;
Swap(c, d);
cout << "c = " << c << ", d = " << d << endl;

string e = "aaa";
string f = "bbb";
cout << "e = " << e << ", f = " << f << endl;
Swap(e, f);
cout << "e = " << e << ", f = " << f << endl;

system("pause");
return 0;
}

输出结果：



利用同一个函数模板可以应用于不同的类型，上面的每一次Swap的调用其实本质都是：

Swap(a, b);   ------>     Swap<int>(a, b);
Swap(c, d);   ------>     Swap<double>(c, d);
Swap(e, f);   ------>     Swap<string>(e, f);

这个过程就是从函数模板转换成模板函数的一个过程， 左边是一种函数模板的隐式实例化，右边是函数模板的显示实例化。

1、函数模板与普通函数重载

template<typename T>
T getmax(T a, T b) {
return a > b ? a : b;
}

int getmax(int a, int b) {
return a > b ? a : b;
}

int main(){
cout << getmax(8,5) << endl;
system("pause");
return 0;
}

对于这样的代码，编译器采用完全匹配的方式调用参数为int类型的函数

int getmax(int a, int b) {
return a > b ? a : b;
}

因为函数模板的编译需要进行两次编译：

第一次：不考虑类型编译；

第二次：匹配类型，生成可调用的二进制文件

在第一次编译的时候编译器就找到了完全匹配的函数，因为不会再进行第二次编译了。

所以当函数模板与普通函数重载时，优先调用完全匹配的普通函数。

2、函数模板与函数模板重载

template<typename T>
T* const& getmax(T* const& a, T* const& b) {
return *a > *b ? *a : *b;
}

template<typename T>
T const& getmax(T const& a, T const& b) {
return a > b ? a : b;
}

int main(){
cout << getmax(5,8) << endl;
system("pause");
return 0;
}

这段代码会调用下面这个模板函数，

template<typename T>
T const& getmax(T const& a, T const& b) {
return a > b ? a : b;
}

当模板函数与模板函数重载时，根据参数列表进行匹配。

二、结构体模板

template<typename T>
struct student
{
T num;
string name;
int age;
};

int main(){
student<int> stu1 = {1239234, "郭靖", 18};
cout << stu1.num << "   " << stu1.name << "   " << stu1.age << endl;
student<string> stu2 = {"xuesheng2", "黄蓉", 16};
cout << stu2.num << "   " << stu2.name << "   " << stu2.age << endl;
system("pause");
return 0;
}

输出结果：



三、类模板

STL中常用的就是类模板，比如vector，stack都是类模板，这里就拿stack为例：

类模板的格式：

template<typename T1, typename T2, ...>
class 类名{
类内部实现;
};

若成员函数在类内部定义则与普通类的成员函数的定义一样， 若成员函数在类外部定义则要这样写，以下面stack的构造函数为例，在函数前不仅要加

template<typename T>

域名要写成这种形式:

MyStack<T>::函数名

自实现的Stack类模板

template<typename T>
MyStack<T>::MyStack(int s) {
size = s;
arr = new T[size];
top = 0;
}

#include<iostream>
#include<string>

using namespace std;

template<typename T>
class MyStack {
public:
MyStack(int s = 1024);
~MyStack();
bool isEmpty();
bool isFull();
void push(T num);
T pop();
private:
T *arr;
int top;
int size;
};

template<typename T>
MyStack<T>::MyStack(int s) {
size = s;
arr = new T[size];
top = 0;
}

template<typename T>
MyStack<T>::~MyStack() {
delete[]arr;
}

template<typename T>
bool MyStack<T>::isEmpty() {
return top == 0;
}

template<typename T>
bool MyStack<T>::isFull() {
return top == size;
}

template<typename T>
void MyStack<T>::push(T num) {

arr[top++] = num;
}

template<typename T>
T MyStack<T>::pop() {
return arr[--top];
}

int main() {
MyStack<int> ms;
ms.push(20);
cout << ms.pop() << endl;
ms.push(30);
cout << ms.pop() << endl;
ms.push(10);
cout << ms.pop() << endl;
cout << "-------------------" << endl;
MyStack<string> mstr;
mstr.push("aaa");
cout << mstr.pop() << endl;
mstr.push("bbb");
cout << mstr.pop() << endl;
mstr.push("ccc");
cout << mstr.pop() << endl;

cout << "-------------------" << endl;
MyStack<double> msdou;
msdou.push(1.1);
cout << msdou.pop() << endl;
msdou.push(2.2);
cout << msdou.pop() << endl;
msdou.push(3.3);
cout << msdou.pop() << endl;
system("pause");
return 0;
}

输出结果：

MyStack<int> ms

对于这句代码，是个从类模板转换成模板类，再生成对象的过程。

如果写类模板，最好是先用一种简单的类型写一遍，再把类型替换掉就可以了。

再粘一个自实现的vector的例子，个人认为还是蛮典型的：

#include<iostream>

using namespace std;

template<typename T>
class MyVector {
public:
MyVector(int s = 1024) {
arr = new T[s];
size = 0;
}

MyVector(MyVector<T> &another) {
int len = another.getSize();
arr = new T[len];
for (int i = 0; i < len; i++) {
arr[i] = another.arr[i];
size++;
}
}

MyVector<T>& operator=(MyVector<T> & another) {
if (this == &another)
return *this;
delete[]arr;
int len = another.getSize();
arr = new T[len];
for (int i = 0; i < len; i++) {
arr[i] = another.arr[i];
size++;
}
return *this;
}

T& operator[](int i) {
if (i > size){
cerr << i << "不存在" << endl;
}
return arr[i];
}

~MyVector() {
delete []arr;
}
int getSize() {
return size;
}

void push_back(T num) {
arr[size++] = num;
}

T pop_back() {
return arr[--size];
}

friend ostream& operator<<(ostream& os, const MyVector& mv) {
for (int i = 0; i < mv.size; i++)
os << mv.arr[i] << " ";
return os;
}

private:
T *arr;
int size;
};

int main() {
MyVector<int> mv;
for(int i = 0; i < 10; i++)
mv.push_back(i);
cout << mv << endl;
cout << "------------------------" << endl;

MyVector<double> v2;
for (int i = 0; i < 10; i++)
v2.push_back(i + 0.1);
cout << v2 << endl;
cout << "------------------------" << endl;

MyVector<char> v3;
char c = 'a';
for(int i = 0; i < 10; i++){
v3.push_back(c++);
}
cout << v3 << endl;
cout << "------------------------" << endl;
system("pause");
return 0;
}

输出结果：



四、模板特化

template<typename T1, typename T2>
class Temp {
public:
void func(T1 t1, T2 t2) {
cout << "class Temp " << endl;
}
};

//完全特化
template<>    //这里不能漏掉
class Temp<int, double> {
public:
void func(int t1, double t2) {
cout << "class Temp<int, double>" << endl;
}
};

//局部特化
template<typename T>
class Temp<T, double>{
public:
void func(T t1, double t2) {
cout << "class Temp<T, double>" << endl;
}
};

template<typename T>
class Temp<T, T> {
public:
void func(T t1, T t2) {
cout << "class Temp<T, T>" << endl;
}
};

int main(){
Temp<int, int> temp1;
temp1.func(1, 2);
Temp<int, double> temp2;
temp2.func(1, 2.0);
Temp<float, double> temp3;
temp3.func(1.3, 2.5);
Temp<char, string> temp4;
temp4.func('a', "sfafsa");
system("pause");
return 0;
}

输出结果：



五、模板默认参数

1、类模板默认参数

template<typename T1 = int, typename T2 = double>
class test {
public:
void func() {
cout << typeid(t1).name() << "   " << typeid(t2).name() << endl;
}
private:
T1 t1;
T2 t2;
};
int main(){
test<> test1;    //虽然使用了默认参数，但是<>不能少
test1.func();
test<float> test2;
test2.func();
test<char, int> test3;
test3.func();
system("pause");
return 0;
}

输出结果：



2、函数模板默认参数

template<typename T = int>
void foo(T t) {
cout << typeid(t).name() << endl;
}

int main(){
foo("strsqa");
foo((float)12);
system("pause");
return 0;
}

输出结果：



3、类模板中的成员函数模板

template<typename T1 = int, typename T2 = double>
class test {
public:
template<typename T = int>
void func(T t) {
cout << typeid(t1).name() << "   " << typeid(t2).name() << "   " << typeid(t).name() << endl;
}
private:
T1 t1;
T2 t2;
};

int main(){
test<> test1;
test1.func(1);
test<float> test2;
test2.func((float)1);
test<char, int> test3;
test3.func((double)1);
system("pause");
return 0;
}

输出结果：



总结：

1、模板不是一个完整的类型，使用到类型时要用到尖括号<>。

2、结构体模板和类模板必须使用显示实例化，也就是必须加<>,函数模板可以隐式实例化。