C++ 模版

泛型(Generic Programming)即是指具有在多种数据类型上皆可操作的含意。泛型编程的代表作品 STL 是一种高效、泛型、可交互操作的软件组件。泛型编程最初诞生于 C++中，目的是为了实现 C++的 STL（标准模板库）。其语言支持机制就是模板（Templates）。模板的精神其实很简单：参数化类型。换句话说，把一个原本特定于某个类型的算法或类当中的类型信息抽掉，抽出来做成模板参数 T。

1. 函数模版

1.1 函数重载实现的泛型

void Swap(int & a, int &b)
{
	int t = a;
	a = b;
	b = t;
}
void Swap(double & a, double &b)
{
	double t = a;
	a = b;
	b = t;
}
int main()
{
	long a = 2; long b = 3;
	Swap(a,b);
	cout<<a<<b<<endl;
	return 0;
}

1.2 函数模版的引入

1.2.1语法格式

template<typename/class 类型参数表>
返回类型 函数模板名(函数参数列表)
{
	函数模板定义体
}

template 是语义是模板的意思，尖括号中先写关键字 typename 或是 class ，后面跟一个类型 T,此类即是虚拟的类型。至于为什么用 T，用的人多了，也就是T了。

1.2.2 实例

调用过程是：先将函数模板实例化为函数，然后再发生函数调用。

#include <iostream>
using namespace std;
template <typename T>
void Swap(T& a,T &b )
{
    T t = a;
    a = b;
    b = t;
}
int main()
{
    int ia = 10; int ib = 20;
    Swap(ia,ib); //Swap<int>(ia,ib);
    cout<<ia<<ib<<endl;
    double da = 10, db = 20;
    Swap(da,db); //Swap<double>(da,db);
    cout<<da<<db<<endl;
    string sa ="china"; string sb = "America";
    Swap(sa,sb);
    cout<<sa<<sb<<endl;
    return 0;
}

1.2.3 小结

函数模板，只适用于函数的参数个数相同而类型不同，且函数体相同的情况。如果个数不同，则不能用函数模板。

2. 类模版

引例

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
using namespace std;
class Stack
{
public:
    Stack(int size=1024);
    ~Stack();
    bool isEmpty();
    bool isFull();
    void push(int data);
    int pop();
private:
    int* space;
    int top;
};
Stack::Stack(int size)
{
    space = new int[size];
    top = 0;
}
Stack::~Stack()
{
    delete []space;
}
bool Stack::isEmpty()
{
    return top == 0;
}
bool Stack::isFull()
{
    return top == 1024;
}
void Stack::push(int data)
{
    space[top++] = data;
}
int Stack::pop()
{
    return space[--top];
}
int main()
{
    Stack s(100);
    if(!s.isFull())
    s.push(10);
    if(!s.isFull())
    s.push(20);
    if(!s.isFull())
    s.push(30);
    if(!s.isFull())
    s.push(40);
    if(!s.isFull())
    s.push(50);
    while(!s.isEmpty())
    cout<<s.pop()<<endl;
    return 0;
}

上述栈，如果想模板化，可以 push 和 pop 不同的数据类型。主要由几个因素需要把控。栈中的空间元素类型，压入元素类型，弹出元素类型，三者保持一致即可。

2.1 语法

2.1.1 类模板定义

template<typename T>
class Stack
{
}

2.1.2 类内定义成员函数

template<typename T>
class Stack
{
public:
	Stack(int size)
	{
		space = new T[size];
		top = 0;
	}
}

2.1.3 类外定义函数

template<typename T>
void Stack<T>::push(T data)
{
	space[top++] = data;
}

2.1.4 类模板实例化为模板类

类模板是类的抽象，类是类模板的实例。

Stack<double> s(100);

2.2 类模版实例

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
using namespace std;
template<typename T>
class Stack
{
public:
	Stack(int size)
	{
		space = new T[size];
		top = 0;
	}
	~Stack();
	bool isEmpty();
	bool isFull();
	void push(T data);
	T pop();
	private:
	T* space;
	int top;
};
template<typename T>
Stack<T>::~Stack()
{
	delete []space;
}
template<typename T>
bool Stack<T>::isEmpty()
{
	return top == 0;
}
template<typename T>
bool Stack<T>::isFull()
{
	return top == 1024;
}
template<typename T>
void Stack<T>::push(T data)
{
	space[top++] = data;
}
template<typename T>
T Stack<T>::pop()
{
	return space[--top];
}
int main()
{
	Stack<double> s(100); //Stack<string> s(100);
	if(!s.isFull())
	s.push(10.3);
	if(!s.isFull())
	s.push(20);
	if(!s.isFull())
	s.push(30);
	if(!s.isFull())
	s.push(40);
	if(!s.isFull())
	s.push(50);
	while(!s.isEmpty())
	cout<<s.pop()<<endl;
	return 0;
}

注意事项

模板定义很特殊。由 template<…> 处理的任何东西都意味着编译器在当时不为它分配存储空间，它一直处于等待状态直到被一个模板实例告知。在编译器和连接器的某一处，有一机制能去掉指定模板的多重定义。所以为了容易使用，几乎总是在头文件中放置全部的模板声明和定义,文件后缀为.hpp。