基本语法：

template <typename T>
void mySwap(T& a, T& b)
{//类型参数化T temp = a;a = b;b = temp;
}
void test01()
{int a = 10, b = 20;//自动类型推导mySwap(a,b);//显示指定类型mySwap<int>(a, b);
}

实例：数组排序

template<class T>
void mySort(T arr[], int len)
{cout << len << endl;for (int i = 0; i < len-1; i++){int max = i;for (int j = i + 1; j < len; j++){if (arr[max] < arr[j]){max = j;}}if (max != i){mySwap(arr[max], arr[i]);}}
}
template <typename T>
void PrintArr(T arr[], int len)
{for (int i = 0; i < len; i++)cout << arr[i] << " ";cout << endl;
}
void test02()
{char charArr[] = "badcef";int num = sizeof(charArr)/ sizeof(char);num -= 1;//消除'\0'的影响mySort(charArr, num);PrintArr(charArr, num);int intArr[] = { 0,2,1,3,4,5 };num = sizeof(intArr) / sizeof(int);mySort(intArr, num);PrintArr(intArr, num);
}

普通函数与函数模板的区别：

普通函数可以发生隐式类型转换，而对于函数模板，自动类型转换不可以发生隐式类型转换
，显示指定类型可以发生隐式类型转换。

template<typename T>
T myAdd(T a, T b)
{return a + b;
}
void test03()
{int a = 10;char c = 'c';cout << myAdd<int>(a, c) << endl;
}

普通函数与函数模板的调用规则：

//如果函数模板和普通函数都可以调用，优先调用普通函数

//通过空模板的参数列表，强制调用函数模板

//如果函数模板产生更好的匹配，优先调用函数模板

void myPrint(int a, int b)
{cout << "调用普通函数" << endl;
}
template<typename T>
void myPrint(T a, T b)
{cout << "调用函数模板" << endl;
}template<typename T>
void myPrint(T a, T b,T c)
{cout << "调用重载的函数模板" << endl;
}
void test04()
{int a = 10, b = 20;//如果函数模板和普通函数都可以调用，优先调用普通函数myPrint(a, b);//通过空模板的参数列表，强制调用函数模板myPrint<>(a, b);myPrint<>(a, b, 1);//如果函数模板产生更好的匹配，优先调用函数模板char c1 = 'c', c2 = 'a';myPrint(c1, c2);
}

模板的局限性：

class Person
{
public:Person(string name,int age){m_Name = name;m_age = age;}string m_Name;int m_age;
};
template<class T>
bool myComp(T& a, T& b)
{if (a == b)return true;else return false;
}
template<> bool myComp(Person& a, Person& b)
{if (a.m_age == b.m_age && a.m_Name == b.m_Name)return true;else return false;
}
void test05()
{Person p1("Tom", 10); Person p2("Tom", 10);bool ret = myComp(p1, p2);if (ret){cout << "p1==p2" << endl;}else cout << "P1!=p2" << endl;
}