template<typename T, typename Y> // 這也可以寫 template<class T, class Y> 此處的 class 和 typename 作用相同
void tfunc(T& t, Y& y) {
 cout << t << " " << y << endl;
}
int n = 2;
double d = 2.1;
tfunc(n, d);

// 運行結果：2 2.1

// ====== 測試一：函數模板針對特殊數據類型具體化 ======
struct Node {
 int val;
 Node* next;
};
// 函數模板
template<typename T> 
void tfunc(const T& t) {
 cout << "template: " << t << endl;
}
// 函數模板具體化(用于處理Node類型數據)
template<> 
void tfunc<Node>(const Node& node) {
 cout << "template<Node>: " << node.val << endl;
}
// 函數模板具體化(用于處理int類型數據)
template<> 
void tfunc<int>(const int& n) {
 cout << "template<int>: " << n << endl;
}
// 普通函數
void tfunc(const int& n) {
 cout << "tfunc(): " << n << endl;
}
double d = 2.1;
tfunc(d); // 函數模板未具體化double類型函數，調用模板
Node node{ 2, nullptr };
tfunc(node); // 函數模板具體化Node類型函數，調用函數模板的具體化
int n = 2;
tfunc(n); // 函數模板具體化int類型函數，也存在普通函數，調用普通函數
// ====== 測試二：函數模板部分具體化 ======
template<typename T1, typename T2>
void tfunc(T1 t1, T2 t2) {
 cout << typeid(T1).name() << " and " << typeid(T2).name() <<": " << t1 << " " << t2 << endl;
}
template<typename T1>
void tfunc(T1 t1, int i) {
 cout << typeid(T1).name() << " and " << "int: " << t1 << " " << i << endl;
}
template<typename T2>
void tfunc(long l, T2 t2) {
 cout << "long and " << typeid(T2).name() << ": " << l << " " << t2 << endl;
}
template<>
void tfunc(short l, int i) {
 cout << "long and int: " << l << " " << i << endl;
}
// 分別調用以上四個模板函數
tfunc(char('c'), char('c'));
tfunc(char('c'), int(10));
tfunc(long(10), char('c'));
tfunc(short(10), int(10));

// 函數模板
template<typename T> 
void tfunc(const T& t) {
 cout << "template: " << t << endl;
}

// 函數模板實例化，不用寫函數的實現，編譯器會生成該類型的模板具體化函數
template void tfunc<char>(const char& c);

template<typename T = int, typename Y = char> // 此處指定了模板默認參數，部分指定必須從右到左指定
class Test {
public:
 Test(T t, Y y) : t(t), y(y) {
 }
 void tfunc();
private:
 T t;
 Y y;
};
template<typename T, typename Y> // 類模板的函數在類外實現，需要加上模板參數列表，但不需要加指定的默認模板參數
void Test<T, Y>::tfunc() { // 類外使用Test需要加模板參數
 cout << t << " " << y << endl;
}
int n = 2;
double d = 2.1;
Test<int, double> test(n, d); // 此處如果使用默認模板參數可定義為 Test<> test(int(2), char('a'));
test.tfunc();
// 運行結果：2 2.1

// ====== 測試一 ======
template<typename T, typename Y>
class A {
public:
 A(T t, Y y) {
 }
};
class Test : public A<int, double> { // 父類是類模板，子類是普通類
public:
 Test() : A<int, double>(2, 2.1) {
 }
};
Test();
// ====== 測試二 ======
template<typename T, typename Y>
class A {
public:
 A(T t) {
 }
};
template<typename X, typename Z, typename P>
class Test : public A<X, P> {
public:
 Test(X x, Z z, P p) : A<X, P>(x) {
 }
};
Test<int, double, char>(int(2), double(2.1), char('a'));

// ====== 測試一 ======
template<typename T, typename Y> 
class A {
public:
 virtual void tfunc(T t, Y y) = 0;
};
class Test : public A<int, double> { 
public:
 virtual void tfunc(int n, double d) {
 cout << n << " " << d << endl;
 }
};
// 父類是類模板，子類是普通類，在多態(tài)情況下父類需要指定模板參數，子類就不用了
A<int, double>* a = new Test;
a->tfunc(2, 2.1);
// 運行結果：2 2.1
// ====== 測試二 ======
template<typename T, typename Y> 
class A {
public:
 virtual void tfunc(T t, Y y) = 0;
};
template<typename X, typename Z, typename P>
class Test : public A<X, P> {
public:
 virtual void tfunc(X x, P p) {
 cout << x << " " << p << endl;
 }
};

// 父類是類模板，子類是類模板，在多態(tài)情況下父類和子類都需要指定模板參數
A<int, double>* a = new Test<int, char, double>;
a->tfunc(2, 2.1);
// 運行結果：2 2.1

template<typename T1, typename T2>
class Test {
public:
 Test() {
 cout << "T1 and T2" << endl;
 }
};
// 部分具體化
template<typename T1>
class Test<T1, int> {
public:
 Test() {
 cout << "T1 and int" << endl;
 }
};
// 部分具體化
template<typename T2>
class Test<long, T2> {
public:
 Test() {
 cout << "long and T2" << endl;
 }
};
// 全部具體化
template<>
class Test<long, int> {
public:
 Test() {
 cout << "long and int" << endl;
 }
};
// 分別創(chuàng)建上面四個類
Test<char, char>();
Test<char, int>();
Test<long, char>();
Test<long, int>();

class Base1 { };
class Base2 { };
class Test1 : public Base1 { };
class Test2 : public Base2 { };
template<typename T1, typename T2> 
class Pair {
public:
 T1 t1;
 T2 t2;
 Pair(T1 t1, T2 t2) : t1(t1), t2(t2) {
 }
 // 類模板中的成員模板
 template<typename U1, typename U2>
 Pair(const Pair<U1, U2>& pair) : t1(pair.t1), t2(pair.t2){
 }
};
Pair<Base1*, Base2*>(Pair<Test1*, Test2*>(new Test1, new Test2));