模板特化
介绍
- 模板特化是指在模板的基础上，针对某些特定的值，提供一种特殊的实现方式，模板特化分为两种，类模板特化和函数模板特化
类模板特化
- 类模板特化指的是在类模板上，针对某些特定的类型和值，提供一种特殊的实现方式。类模板特化分为全特化和偏特化两种。
类模板全特化
- 定义
- 示例
// class_Template_Ful_Specification.cpp
/**
* 类模板全特化
* 代码中，定义了一个名为 MyType 的类模板
* 使用类模板全特化提供了一个 int 类型的特殊实现
*/
#include<iostream>
using namespace std;
template <typename T>
class MyType
{
public:
void print(){
cout << "This is a generic type." << endl;
}
};
template <>
class MyType<int>
{
public:
void print(){
cout << "This is an integer type" << endl;
}
};
int main()
{
MyType<float> f;
f.print();
MyType<int> i;
i.print();
return 0;
}
类模板偏特化
- 定义
- 示例
// Class_Template_Partial_Specification.cpp
/**
* 类模板偏特化
* 定义了一个 MyType 的类模板，然后使用类模板提供一个针对第二个参数为 int 类型的特殊实现
*/
#include<iostream>
using namespace std;
template <typename T1, typename T2>
class MyType
{
public:
void print(){
cout << "This is a generic type" << endl;
}
};
template <typename T>
class MyType<T,int>
{
private:
/* data */
public:
void print(){
cout << "This is a type with an interger as its second parmeter." << endl;
}
};
int main()
{
MyType<float, double> f;
f.print();
MyType<int,int> i;
i.print();
return 0;
}
函数模板特化
- 函数模板特化指的是在函数模板的基础上，针对某些特定的类型或值，提供一种特殊的实现方式。函数模板特化分为全特化和偏特化两种：
函数模板全特化
- 定义
- 示例
// Function_Template_Full_Specification.cpp
/**
* 函数模板全特化：
* 定义一个名为 MySwap 的函数模板，然后使用函数模板全特化来提供一个针对 double 类型的特殊实现
*/
#include<iostream>
using namespace std;
template<typename T>
void MySwap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
template <>
void MySwap(double& a, double & b)
{
cout << "This is a special implementation for double types." << endl;
double temp = a;
a = b;
b = temp;
}
int main()
{
int x = 5, y = 10;
MySwap(x,y);
cout <<"X : " << x << " Y : " << y <<endl;
double p = 3.14, q = 6.28;
MySwap(p, q);
cout << "P : " << p << " Q : " << q << endl;
return 0;
}
函数模板偏特化
- 定义
- 示例
// Function_Template_Partial_Specification.cpp
/**
* 函数模板偏特化
*
*/
#include <iostream>
using namespace std;
template<typename A, typename B>
void f(A a, B b)
{
cout << "Normal Version" << endl;
}
// 函数模板偏特化，但是编译器不支持函数模板偏特化
/*
template<typename A>
void fun<A,int>(A a, int b)
{
cout << "Partial Version" << endl;
}
*/
int main()
{
int a = 10;
double b = 12;
f(a,b);
f(a,a);
return 0;
}
#include <iostream>
using namespace std;
// 借助类模板偏特化，使用 Functor 代替函数
template <typename A, typename B>
class F
{
public:
F(A a, B b):a_(a), b_(b){}
void operator() (){
cout << "Normal version" << endl;
}
private:
A a_;
B b_;
};
template <typename A>
class F<A,int>
{
public:
F(A a, int b) : a_(a), b_(b){}
void operator()(){
cout << "Partial version." << endl;
}
private:
A a_;
int b_;
};
int main()
{
int a = 10;
double b = 12;
F<int, double>(a,b)();
F<int,int>(a,a)();
return 0;
}
#include<iostream>
using namespace std;
struct NormalVersionTag{};
struct IntPartialVersionTag{};
template<class T>
struct TagDispatchTrait
{
using Tag = NormalVersionTag;
};
template<>
struct TagDispatchTrait<int>
{
using Tag = IntPartialVersionTag;
};
template <typename A, typename B>
inline void internal_f(A a, B b, NormalVersionTag)
{
cout << "Normal Version" << endl;
}
template <typename A, typename B>
inline void internal_f(A a, B b, IntPartialVersionTag)
{
cout << "Partial Version" << endl;
}
template <typename A, typename B>
void f(A a, B b)
{
return internal_f(a, b, typename TagDispatchTrait<B>::Tag {});
}
int main()
{
int a = 10;
double b = 12;
f(a,b);
f(a,a);
return 0;
}
