---- 整理自狄泰软件唐佐林老师课程
1. 多参数模板
类模板可以定义 任意多个不同的 类型参数
2. 类模板可以被 特化
模板本来是一组通用逻辑的实现,但是可能存在特定的参数类型下,通用的逻辑实现不能满足要求,这时就需要针对这些特殊的类型,而实现一个特例模板——即 模板特化。
- 指定类模板的特定实现
- 部分类型参数必须显示指定
- 根据类型参数分开实现类模板
2.1 类模板的特化类型
- 部分特化:用特定规则约束类型参数
- 完全特化:完全显示指定类型参数
// 主模板类
template <typename T1, typename T2>
class Test
{
};
// 完全特化
template < >
class Test<int, int>
{
};
// 部分特化:对部分模板参数进行特化为一般类型
template <typename T2>
class Test<int, T2>
{
};
// 部分特化:模板参数特化为指针
template <typename T1, typename T2>
class Test<T1*, T2*>
{
};
2.2 编程实验:类模板的特化
#include <iostream>
#include <string>
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<int, float> t1;
Test<long, long> t2;
Test<void*, void*> t3;
t1.add(1, 2.5);
t2.add(5, 5);
t2.print();
t3.add(NULL, NULL);
Test<int*, double*> 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<typename T1, typename T2>
bool Equal(T1 left, T2 right)
{
}
// 函数模板的完全特化
template< >
bool Equal<void*>(void* left, void* right)
{
}
// 函数模板的重载(新的函数模板)
template<typename T1, typename T2>
bool Equal(T1* left, T2* right)
{
}
3.3.2 函数模板之间的重载决议
#include <iostream>
using namespace std;
// 函数主模板
template<typename T1, typename T2>
void Equal(T1 left, T2 right)
{
cout << "template<typename T1, typename T2> void Equal(T1 left, T2 right)" << endl;
}
// 函数模板的完全特化
template< >
void Equal(const char* left, const char* right)
{
cout << "template< > void Equal<const char*>(const char* left, const char* right)" << endl;
}
// 函数模板的重载(新的函数模板)
template<typename T1, typename T2>
void Equal(T1* left, T2* right)
{
cout << "template<typename T1, typename T2> void Equal(T1* left, T2* right)" << endl;
}
int main()
{
Equal("1", "2");
return 0;
}
#include <iostream>
using namespace std;
// 函数主模板
template<typename T1, typename T2>
void Equal(T1 left, T2 right)
{
cout << "template<typename T1, typename T2> void Equal(T1 left, T2 right)" << endl;
}
// 函数模板的重载(新的函数模板)
template<typename T1, typename T2>
void Equal(T1* left, T2* right)
{
cout << "template<typename T1, typename T2> void Equal(T1* left, T2* right)" << endl;
}
// 函数模板的完全特化
template< >
void Equal(const char* left, const char* right)
{
cout << "template< > void Equal<const char*>(const char* left, const char* right)" << endl;
}
int main()
{
Equal("1", "2");
return 0;
}
3.3.3 普通函数与函数模板间的重载决议
#include <iostream>
using namespace std;
// 函数主模板
template<typename T1, typename T2>
void Equal(T1 left, T2 right)
{
cout << "template<typename T1, typename T2> void Equal(T1 left, T2 right)" << endl;
}
// 函数模板的完全特化
template< >
void Equal(const char* left, const char* right)
{
cout << "template< > void Equal<const char*>(const char* left, const char* right)" << endl;
}
// 函数模板的重载(新的函数模板)
template<typename T1, typename T2>
void Equal(T1* left, T2* right)
{
cout << "template<typename T1, typename T2> 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 <iostream>
#include <string>
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>(double a, double b)
{
const double delta = 0.00000000000001;
double r = a - b;
cout << "bool Equal<double>(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. 小结
- 类模板可以定义任意多个不同的类型参数
- 类模板可以被部分特化和完全特化
- 特化的本质是模板的分开实现
- 函数模板只支持完全特化
- 工程中使用模板特化代替类(函数)重定义