---- 整理自狄泰软件唐佐林老师课程

1. 多参数模板

类模板可以定义 任意多个不同的 类型参数

2. 类模板可以被 特化

模板本来是一组通用逻辑的实现，但是可能存在特定的参数类型下，通用的逻辑实现不能满足要求，这时就需要针对这些特殊的类型，而实现一个特例模板——即 模板特化。

• 指定类模板的特定实现
• 部分类型参数必须显示指定
• 根据类型参数分开实现类模板

2.1 类模板的特化类型

• 部分特化：用特定规则约束类型参数
• 完全特化：完全显示指定类型参数

// 主模板类
template  
class Test
{
};

// 完全特化
template < > 
class Test
{
};

// 部分特化：对部分模板参数进行特化为一般类型
template  
class Test
{
};

// 部分特化：模板参数特化为指针
template  
class Test
{
};

2.2 编程实验：类模板的特化

#include 
#include using namespace std;template
< typename T1, typename T2 >
class Test
{
public:void add(T1 a, T2 b){cout << "void add(T1 a, T2 b)" << endl;cout << a + b << endl;}
};template
< typename T1, typename T2 >
class Test < T1*, T2* >      // 关于指针的特化实现
{
public:void add(T1* a, T2* b){cout << "void add(T1* a, T2* b)" << endl;cout << *a + *b << endl;}
};template
< typename T >
class Test < T, T >    // 当 Test 类模板的两个类型参数完全相同时，使用这个实现
{
public:void add(T a, T b){cout << "void add(T a, T b)" << endl;cout << a + b << endl;}void print(){cout << "class Test < T, T >" << endl;}
};template
<  >
class Test < void*, void* >    // 当 T1 == void* 并且 T2 == void* 时
{
public:void add(void* a, void* b){cout << "void add(void* a, void* b)" << endl;cout << "Error to add void* param..." << endl;}
};int main()
{  Test t1;Test t2;Test t3;t1.add(1, 2.5);t2.add(5, 5);t2.print();t3.add(NULL, NULL);Test t4;int a = 1;double b = 0.1;t4.add(&a, &b);return 0;
}

2.3 类模板特化注意事项

• 特化只是模板的分开实现
  • 本质上是 同一个类模板
• 特化类模板的使用方式是统一的
  • 必须 显示 指定每一个类型参数

3. 特化的深度分析

3.1 问题

类模板特化与重定义有区别吗？函数模板可以特化吗？

3.2 重定义和特化的不同

• 重定义
  • 一个类模板和一个新类（或者两个类模板）
  • 使用的时候需要 考虑如何选择的问题
• 特化
  • 以统一的方式使用类模板和特化类
  • 编译器自动优先选择特化类

3.3 函数模板的特化

部分内容引用修改自：
https://blog.csdn.net/zhaominyong/article/details/109265862

3.3.1 函数模板只支持类型参数完全特化

// 常规函数
bool Equal(const char* left, const char* right)
{
}

// 函数主模板
template 
bool Equal(T1 left, T2 right)
{
}

// 函数模板的完全特化
template< > 
bool Equal(void* left, void* right)
{
}

// 函数模板的重载（新的函数模板）
template 
bool Equal(T1* left, T2* right)
{
}

3.3.2 函数模板之间的重载决议

#include 
using namespace std;// 函数主模板
template
void Equal(T1 left, T2 right)
{cout << "template void Equal(T1 left, T2 right)" << endl;
}// 函数模板的完全特化
template< >
void Equal(const char* left, const char* right)
{cout << "template< > void Equal(const char* left, const char* right)" << endl;
}// 函数模板的重载（新的函数模板）
template
void Equal(T1* left, T2* right)
{cout << "template void Equal(T1* left, T2* right)" << endl;
}int main()
{Equal("1", "2");return 0;
}

#include 
using namespace std;// 函数主模板
template
void Equal(T1 left, T2 right)
{cout << "template void Equal(T1 left, T2 right)" << endl;
}// 函数模板的重载（新的函数模板）
template
void Equal(T1* left, T2* right)
{cout << "template void Equal(T1* left, T2* right)" << endl;
}// 函数模板的完全特化
template< >
void Equal(const char* left, const char* right)
{cout << "template< > void Equal(const char* left, const char* right)" << endl;
}int main()
{Equal("1", "2");return 0;
}

3.3.3 普通函数与函数模板间的重载决议

#include 
using namespace std;// 函数主模板
template
void Equal(T1 left, T2 right)
{cout << "template void Equal(T1 left, T2 right)" << endl;
}// 函数模板的完全特化
template< >
void Equal(const char* left, const char* right)
{cout << "template< > void Equal(const char* left, const char* right)" << endl;
}// 函数模板的重载（新的函数模板）
template
void Equal(T1* left, T2* right)
{cout << "template void Equal(T1* left, T2* right)" << endl;
}// 普通函数
void Equal(const char* left, const char* right)
{cout << "void Equal(const char* left, const char* right)" << endl;
}int main()
{Equal("1", "2");return 0;
}

3.4 编程实验：特化的深入理解

#include 
#include using namespace std;template
< typename T1, typename T2 >
class Test
{
public:void add(T1 a, T2 b){cout << "void add(T1 a, T2 b)" << endl;cout << a + b << endl;}
};/*
template
<  >
class Test < void*, void* >    // 当 T1 == void* 并且 T2 == void* 时
{
public:void add(void* a, void* b){cout << "void add(void* a, void* b)" << endl;cout << "Error to add void* param..." << endl;}
};
*/class Test_Void
{
public:void add(void* a, void* b){cout << "void add(void* a, void* b)" << endl;cout << "Error to add void* param..." << endl;}
};template < typename T >
bool Equal(T a, T b)
{cout << "bool Equal(T a, T b)" << endl;return a == b;
}template < >
bool Equal(double a, double b)
{const double delta = 0.00000000000001;double r = a - b;cout << "bool Equal(double a, double b)" << endl;return (-delta < r) && (r < delta);
}bool Equal(double a, double b)
{const double delta = 0.00000000000001;double r = a - b;cout << "bool Equal(double a, double b)" << endl;return (-delta < r) && (r < delta);
}int main()
{  cout << Equal( 1, 1 ) << endl;cout << Equal<>( 0.001, 0.001 ) << endl;return 0;
}

3.5 工程中的建议

• 当需要重载函数模板时，优先考虑使用模板特化
• 当模板特化无法满足需求时，再使用函数重载（如上例）

4. 小结

• 类模板可以定义任意多个不同的类型参数
• 类模板可以被部分特化和完全特化
• 特化的本质是模板的分开实现
• 函数模板只支持完全特化
• 工程中使用模板特化代替类（函数）重定义