C++ 模板特化与偏特化

已于 2023-09-21 10:32:43 修改
阅读量2.4w 收藏 184
点赞数 54
分类专栏： 《C++ 进阶心法 V2》 文章标签： C++ 模板特化 模板偏特化
于 2018-08-29 10:25:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/K346K346/article/details/82179205
版权

文章目录

1.模板特化

1.1 概述

模板特化（template specialization）不同于模板实例化，模板参数在某种特定类型下的具体实现称为模板特化。

模板特化有时也称之为模板的具体化，分为函数模板特化和类模板特化。

1.2 函数模板特化

函数模板特化指函数模板在模板参数为特定类型下的特定实现。

#include <iostream>
using namespace std;

template<typename T> T Max(T t1,T t2) {
	return (t1>t2)?t1:t2;
}

typedef const char* CCP;
template<> CCP Max<CCP>(CCP s1,CCP s2) {
	return (strcmp(s1,s2)>0)?s1:s2;
}

int main() {
	// 隐式调用实例：int Max<int>(int,int)
	int i=Max(10,5);
	
	// 显式调用特化版本：const char* Max<const char*>(const char*,const char*)
	const char* p=Max<const char*>("very","good");
	cout<<"i:"<<i<<endl;
	cout<<"p:"<<p<<endl;
}

程序正常编译运行结果：

i:10
p:very

在函数模板显示特化定义（Explicit Specialization Definition）中，先是关键字 template 和一对尖括号 <>，然后是函数模板特化的定义。该定义指出了模板名、被用来特化模板的模板实参，以及函数参数表和函数体。在上面的程序中，如果不给出函数模板Max<T>在 T 为 const char* 时的特化版本，那么在比较两个字符串大小时，比较的是字符串起始地址的大小，而不是字符串内容在字典序中的先后次序。

除了定义函数模板特化版本外，还可以直接给出模板函数在特定类型下的重载形式（普通函数）。使用函数重载可以实现函数模板特化的功能，也可以避免函数模板的特定实例的失效。例如，把上面的模板特化可以改成如下重载函数。

typedef const char* CCP;
CCP Max(CCP s1,CCP s2) {
	return (strcmp(s1,s2)>0)?s1:s2;
}

程序运行结果和使用函数模板特化相同。但是，使用普通函数重载和使用模板特化还是有不同之处，主要表现在如下两个方面：

（1）如果使用普通重载函数，那么不管是否发生实际的函数调用，都会在目标文件中生成该函数的二进制代码。而如果使用模板的特化版本，除非发生函数调用，否则不会在目标文件中包含特化模板函数的二进制代码。这符合函数模板的“惰性实例化”准则。

（2）如果使用普通重载函数，那么在分离编译模式下，需要在各个源文件中包含重载函数的申明，否则在某些源文件中就会使用模板函数，而不是重载函数。

1.3 类模板特化

类模板特化类似于函数模板的特化，即类模板参数在某种特定类型下的具体实现。考察如下代码：

#include <iostream>
using namespace std;

template<typename T>class A {
	T num;
public:
	A(){
		num=T(6.6);
	}
	void print(){
		cout<<"A'num:"<<num<<endl;
	}
};

template<> class A<char*> {
	char* str;
public:
	A() {
		str="A' special definition ";
	}
	void print() {
		cout<<str<<endl;
	}
};

int main() {
	A<int> a1;      //显示模板实参的隐式实例化
	a1.print();
	A<char*> a2;    //使用特化的类模板
	A2.print();
}

程序输出结果如下：

A'num:6
A' special definition

2.模板偏特化

2.1 概述

模板偏特化（Template Partitial Specialization）是模板特化的一种特殊情况，指显示指定部分模板参数而非全部模板参数，或者指定模板参数的部分特性分而非全部特性，也称为模板部分特化。与模板偏特化相对的是模板全特化，指对所有模板参数进行特化。模板全特化与模板偏特化共同组成模板特化。

模板偏特化主要分为两种，一种是指对部分模板参数进行全特化，另一种是对模板参数特性进行特化，包括将模板参数特化为指针、引用或是另外一个模板类。

2.2 函数模板偏特化

假如我们有一个 compare 函数模板，在比较数值大小时没有问题，如果传入的是数值的地址，我们需要比较两个数值的大小，而非比较传入的地址大小。此时我们需要对 compare 函数模板进行偏特化。考察如下代码：

#include <vector>
#include <iostream> 
using namespace std;

// 函数模板
template<typename T, class N> void compare(T num1, N num2) {
	cout << "standard function template" << endl;
	if(num1>num2) {
		cout << "num1:" << num1 << " > num2:" << num2 <<endl;
	} else {
		cout << "num1:" << num1 << " <= num2:" << num2 << endl;
	}
}

// 对部分模板参数进行特化
template<class N> void compare(int num1, N num2) {
	cout<< "partitial specialization" <<endl;
	if (num1>num2)
		cout << "num1:" << num1 << " > num2:" << num2 << endl;
	else
		cout << "num1:" << num1 << " <= num2:" << num2 << endl;
}

// 将模板参数特化为指针(模板参数的部分特性)
template<typename T, class N> void compare(T* num1, N* num2) {
	cout << "new partitial specialization" << endl;
	if (*num1>*num2)
		cout << "num1:" << *num1 << " > num2:" << *num2 << endl;
	else
		cout << "num1:" << *num1 << " <= num2:" << *num2 << endl;
}

// 将模板参数特化为另一个模板类
template<typename T, class N> void compare(std::vector<T>& vecLeft, std::vector<T>& vecRight) {
	cout << "to vector partitial specialization" << endl;
	if (vecLeft.size()>vecRight.size())
		cout << "vecLeft.size()" << vecLeft.size() << " > vecRight.size():" << vecRight.size() << endl;
	else
		cout << "vecLeft.size()" << vecLeft.size() << " <= vecRight.size():" << vecRight.size() << endl;
}

int main() {
	// 调用非特化版本 compare<int,int>(int num1, int num2)
	compare<int,int>(30,31);

	// 调用偏特化版本 compare<char>(int num1, char num2)
	compare(30,'1');

	int a = 30;
	char c = '1';
	// 调用偏特化版本 compare<int,char>(int* num1, char* num2)
	compare(&a, &c);

	vector<int> vecLeft{0};
	vector<int> vecRight{1,2,3};
	// 调用偏特化版本 compare<int,char>(int* num1, char* num2)
	compare<int,int>(vecLeft,vecRight);
}

程序输出结果如下：

standard function template
num1:30 <= num2:31
partitial specialization
num1:30 <= num2:1
new partitial specialization
num1:30 <= num2:1
to vector partitial specialization
vecLeft.size()1 <= vecRight.size():3

2.3 类模板偏特化

类模板的偏特化与函数模板的偏特化类似。考察如下代码：

#include <vector>
#include <iostream> 
using namespace std;

// 类模板
template<typename T, class N> class TestClass {
public:
	static bool comp(T num1, N num2) {
		cout <<"standard class template"<< endl;
		return (num1<num2) ? true : false;
	}
};

// 对部分模板参数进行特化
template<class N> class TestClass<int, N> {
public:
	static bool comp(int num1, N num2) {
		cout << "partitial specialization" << endl;
		return (num1<num2) ? true : false;
	}
};

// 将模板参数特化为指针
template<typename T, class N> class TestClass<T*, N*> {
public:
	static bool comp(T* num1, N* num2) {
		cout << "new partitial specialization" << endl;
		return (*num1<*num2) ? true : false;
	}
};

// 将模板参数特化为另一个模板类
template<typename T, class N> class TestClass<vector<T>,vector<N>> {
public:
	static bool comp(const vector<T>& vecLeft, const vector<N>& vecRight) {
		cout << "to vector partitial specialization" << endl;
		return (vecLeft.size()<vecRight.size()) ? true : false;
	}
};

int main() {
	// 调用非特化版本
	cout << TestClass<char, char>::comp('0', '1') << endl;	
	
	// 调用部分模板参数特化版本
	cout << TestClass<int,char>::comp(30, '1') << endl;		

	// 调用模板参数特化为指针版本
	int a = 30;
	char c = '1';
	cout << TestClass<int*, char*>::comp(&a, &c) << endl;		

	// 调用模板参数特化为另一个模板类版本
	vector<int> vecLeft{0};
	vector<int> vecRight{1,2,3};
	cout << TestClass<vector<int>, vector<int>>::comp(vecLeft,vecRight) << endl;	
}

程序输出结果：

standard class template
1
partitial specialization
1
new partitial specialization
1
to vector partitial specialization
1

3.模板类调用优先级

对主版本模板类、全特化类、偏特化类的调用优先级从高到低进行排序是：全特化类>偏特化类>主版本模板类。这样的优先级顺序对性能也是最好的。

但是模板特化并不只是为了性能优化，更多是为了让模板函数能够正常工作，最典型的例子就是 STL中的 iterator_traits。algorithm 中大多数算法通过 iterator 对象来处理数据，但是同时允许以指针代替 iterator 对象，这是为了支持 C-Style Array。如果直接操作 iterator，那么为了支持指针类型，每个算法函数都需要进行重载，因为指针没有::value_type类型。为了解决这个问题，STL 使用了 iterator_traits 对 iterator 特性进行封装，并为指针类型做了偏特化处理，算法通过它来操作 iterator，不需要知道实际操作的是 iterator 对象还是指针。

template<typename IteratorClass> class iterator_traits
...
template<typename ValueType> class iterator_traits<ValueType*>
...
template<typename ValueType> class iterator_traits<ValueType const*>
...

后面两是针对指针类型的偏特化，也是偏特化的一种常见形式。

参考文献

陈刚.C++高级进阶教程[M].武汉:武汉大学出版社,2008.C6.6关于模板特化.P225-229
C++ Primer中文第5版[M]16.5模板特例化
C++类模板的三种特化，讲得比较全面
C++模板全特化、偏特化
Iterator_traits到底有什么用？

恋喵大鲤鱼
关注
专栏目录
C++模板特化与偏特化的说明与代码示例
琅嬛福地
04-09 377
模板特化的定义 模板特化不同于模板的实例化，模板参数在某种特定类型下的具体实现称为模板的特化，以实现特定类型下非通用行为。模板特化有时也称之为模板的具体化，分别有函数模板特化和类模板特化。 特化主要分三种 （1）全特化：将模板的参数全部指定为特定类型，类和函数都支持 （2）偏特化：部分参数指定为特定的类型，模板函数不支持偏特化 （3）特化为另外一个类模板(复杂点的偏特化)，其实这种也是类似于1,2形式 类的特化 例如下面是类的全特化与偏特化的写法： #include <iostream> us
深入分析C++模板特化与偏特化
12-17
1.模板特化 1.1概述 模板特化（template specialization）不同于模板的实例化，模板参数在某种特定类型下的具体实现称为模板的特化。模板特化有时也称之为模板的具体化，分别有函数模板特化和类模板特化。 1.2函数模板特化 函数模板特化是在一个统一的函数模板不能在所有类型实例下正常工作时，需要定义类型参数在实例化为特定类型时函数模板的特定实现版本。查看如下例子。 #include <iostream> using namespace std; template<typename> T Max(T t1,T t2) { return (t1>t2)?t1:t2; } ty
模版的全特化与偏特化
螺蛳粉只吃炸蛋的走风的博客
03-30 1641
本文将详细介绍类模板与函数模板的全特化和偏特化，利用其可以为特定类型或条件创建专门的模板实现，从而提高代码的效率和准确性。
【C++】模板的特化
最新发布
m0_72940975的博客
07-31 1013
比如，在比较两个数的大小时，如果传入两个变量的指针，那么可能会得到错误的结果。此时我们的期望是比较指针所指向的内容的值，那么就需要模板的特化了。通常情况下，使用模板可以实现一些与类型无关的代码，但是有一些类型需要特殊处理，否则可能会得到一些错误的结果。此时，就需要对模板进行特化。即在原模板的基础上，针对特殊类型进行特殊化的实现方式。全特化是将类模板参数列表中所有参数都进行特化。模板的特化又分为函数模板特化和类模板特化。
C++模板特化和偏特化
king_weng的博客
09-22 850
1、模板特化的引入 使用模板时会遇到一些特殊的类型需要特殊处理，不能（或不希望）直接使用当前的模板版本时，所以此时我们就需要对该类型定义一个类或函数的特例化版本。 例：当使用一个判断相等的模板函数时 template<class T> bool Isequal(T& p1, T& p2){ return p1 == p2; } ...
C++——模板特化和偏特化
shineHoo的专栏
07-09 1万+
1.引言C++中的模板分为类模板和函数模板，虽然它引进到C++标准中的时间不是很长，但是却得到了广泛的应用，这一点在STL中有着充分的体现。目前，STL在C++社区中得到了广泛的关注、应用和研究。理解和掌握模板是学习、应用和研究以及扩充STL的基础。而STL模板实例中又充斥着大量的模板特化和偏特化。2.模板的定义(1) 类模板定义一个栈的类模板,它可以用来容纳不同的数据类型说明如下:template class stack {private:  list* top;public:  stack();  st
c++学习(模板特化和偏特化)
myth's blog
12-18 1万+
模板特化和偏特化作者：谢宝陵  周 生(合肥市炮兵学院计算中心 230031)摘要：本文通过例子介绍了在 C++标准库中广泛使用的模板特化和偏特化，并指出了模板特化和偏特化的定义规则和应用规则。关键词：模板、特化、偏特化1.引言C++中的模板分为类模板和函数模板，虽然它引进到C++标准中的时间不是很长，但是却得到了广泛的应用，这一点在STL中有着充分的体现。目前，STL在C++社区中得到了
c++ 模板的特化
S5242的博客
01-11 3981
对模板进行特化,在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化（全特化/偏特化）.
模版的特化与偏特化
andy205214的专栏
03-11 1179
 Partial Template Specialization能够让你在模板(Template)的所有可能的实体中特化出一组子集.  1.模板的特化(template specialization):    例如,定义如下的一个模板:    template    class Widget    {      ... 泛化实现代码 ...    };    然后你可以像下面那样明确地加以特化: 
C++模板之特化与偏特化详解
12-31
对于C++模板特化和偏特化，对于别人来说，已经不是什么新东西了，但是对于我来说，的确是我的盲区，那天在群里讨论这个问题，自己对于这部分确实没有掌握，又联想到在《STL源码剖析》一书中，对于此也是有着介绍。...
模板的全特化与偏特化
热门推荐
thefutureisour的专栏
09-10 4万+
模板为什么要特化，因为编译器认为，对于特定的类型，如果你能对某一功能更好的实现，那么就该听你的。 模板分为类模板与函数模板，特化分为全特化与偏特化。全特化就是限定死模板实现的具体类型，偏特化就是如果这个模板有多个类型，那么只限定其中的一部分。 先看类模板： template class Test { public: Test(T1 i,T2 j):a(i),b(j){cout<<"模板类"
C++模板的特化
weixin_33708432的博客
10-24 112
C++类模板的三种特化，讲得比较全面 By SmartPtr(http://www.cppblog.com/SmartPtr/) 针对一个模板参数的类模板特化的几种类型， 一是特化为绝对类型（全特化）； 二是特化为引用，指针类型(半特化、偏特化)；三是特化为另外一个类模板(复杂点的偏特化)。 用一个简单的例子来说明这三种： // general version template&...
【C++】模板特化
qq_43909184的博客
04-18 981
模板特化的必要性 使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，比如： template <class T> bool IsEqual(T& left, T& right) { return left == right; } void Test() { char* p1 = "hello"; char* p2 = "worl...
c++模板特化
Charon
01-26 3541
c++模板特化一、模板特化, specialization of template模板特化(specialization of template)并不是说实例化一个模板，如template ，class stack；声明stack，这是实例化一个模板类。类模板特化的意思是，对于某个特定的类型，需要对模板进行特殊化，即特殊的处理。例如,stack类模板针对bool类型有特化,因为实际
C++模板特化
weixin_45948264的博客
04-30 435
c++模板特化实现仅存储char/wchar_t类型的链表，实现字符串的链表单个存储
详细介绍c++模板特化
03-12
C++模板特化是指在模板参数确定的情况下，对模板进行特殊的实现。模板特化可以分为两种：完全特化和部分特化。 完全特化是指对模板的所有参数都进行了特化，例如： template <typename T> class MyClass { public: void print() { std::cout << "This is a generic MyClass." << std::endl; } }; template <> class MyClass<int> { public: void print() { std::cout << "This is a specialized MyClass for int." << std::endl; } }; 在这个例子中，我们对 MyClass 进行了完全特化，当模板参数为 int 时，会使用 MyClass<int> 进行特殊实现。 部分特化是指对模板的部分参数进行特化，例如： template <typename T, typename U> class MyClass { public: void print() { std::cout << "This is a generic MyClass." << std::endl; } }; template <typename T> class MyClass<T, int> { public: void print() { std::cout << "This is a partial specialized MyClass for T and int." << std::endl; } }; 在这个例子中，我们对 MyClass 进行了部分特化，当第二个模板参数为 int 时，会使用 MyClass<T, int> 进行特殊实现。 总之，模板特化可以让我们根据不同的模板参数，对模板进行不同的实现，从而提高代码的灵活性和可重用性。
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值