template <typename T>
template <class T1,class T2>多个参数类型
类型 函数名（形式参数表）
{语句序列；
}

template <typename T>//一个模板
void myswap(T& a, T& b)
{T c;c = a;a = b;
}
//调用时，显式说明类型myswap<int>(x,y);myswap<char>(x,y);
//自动类型推倒，尽量不要用myswap(x,y);template <typename T1, typename T2>//两个模板,定义了一定要用
void myswap(T1& a, T2& b)
{}

template <typename T>//一个模板
void myswap(T& a, T& b)
{T c;c = a;a = b;
}
//一个普通函数
void myswap(int& a, char& b)
{int c;c = a;a = b;
}
int a = 10;
char c = 'c';
myswap(a,c) //调用普通函数
myswap(c,a) //调用普通函数，进行隐形类型转换
myswap(a,a) //调用模板函数，严格的类型匹配，不会进行类型转换;但是普通函数如果也有两个int形参时，优先普通函数，看下一个例子

//模板函数重载

int max(int a, int b)
{return a>b?a:b;
}
template<typename T>
T max(T a, T b)
{return a>b?a:b;
}
template<typename T>
T max(T a, T b, T c)
{return max(max(a,b), c);
}int a = 1;
int b = 2;
max(a,b); //函数模板和普通函数都满足调用时，优先普通函数
max<>(a,b);//显示使用函数模板方法，则使用<>空的类型参数化列表
max(3.0,4.0);//类型一致，可以使用模板。且使用普通函数，失真，则调用函数模板
max(3.0,4.0,5.0);//函数模板可以重载
max('a',100);    //类型不一致，不能用函数模板，调用普通函数进行隐式类型转换

template <typename T>
class A
{
public:A(T a=0){this->a = a;}
public:void printA(){cout << "a: " << a << endl;}
protected:T a;
}int main()
{A<int> a1(10); //模板类是抽象的，需要进行类型具体化a1.printA();system("pause");return 0;
}

void useA(A<int>& b) //C++编译器要求具体的参数类
{b.printA();
}useA(a1);

class B:public A<int>
{
public:B(int a=10, int b=20):A<int>(a) //使用初始化参数列表，初始化父类对象，注意父类为模板类时，使用A<int>类类型具体化{this->b = b;}
protected:
private:int b;
}

B b1(1,2);

template <typename T>
class C:public A<T> //基类为模板类型
{
public:C(T c, T a):A<T>(a) //基类为模板类型{this->c = c;}
void printC()
{cout << "c1: " << c << endl;
}
private:T c;
}void main()
{
C<int>c1(1,2);
c1.printC();
system("pause");
}

类内声明：friend ostream& operator<< <T> (ostream& out, Complex &c3); //友元函数声明有<T>
类外实现：template<typename T>
ostream& operator<<(ostream& out, Complex<T>& c3) //友元函数是全局函数，不需要类的作用域
{}

类内声明： Complex operator+(Complex &c2); //正常写就可以啦
类外定义：主要三要素
Complex<T> Complex<T>::operator+(Complex<T>& c2)
{Complex tem(a+c2.a,b+c2.b);return tem;
}