STL运用的C++技术（2）——模板特化 .

最新推荐文章于 2022-09-27 21:22:25 发布
最新推荐文章于 2022-09-27 21:22:25 发布
阅读量677 收藏 2
点赞数
分类专栏： C++
 STL是C++标准库的重要组成部分之一，它不仅是一个可复用的组件库，更是一个包含算法与数据结构的软件框架，同时也是C++泛型编程的很好例子。STL中运用了许多C++的高级技术。本文介绍模板特化技术的运用。主要参考了《C++ Primer》和《STL源码剖析》。

       STL中大量运用了模块，可以说模板是创建类或函数的公式。但是，我们并不总能写出对所有可能被实例化的类型都最合适的模板。举个函数模板特化的例子。

[cpp] view plain copy print ?
  1. template <typename T>  
  2. int Compare(const T &x, const T &y)  
  3. {  
  4.     if(x < y)  
  5.         return -1;  
  6.     else if(x > y)  
  7.         return 1;  
  8.     else  
  9.         return 0;  
  10. }  
template <typename T>
int Compare(const T &x, const T &y)
{
	if(x < y)
		return -1;
	else if(x > y)
		return 1;
	else
		return 0;
}
         对于上面这个函数模板，如果用两个字符串指针来调用，那么比较的是指针值，也就是比较地址大小，而不是字符串的大小。因此为了能够将Compare函数用于字符串，就需要提供一个知道怎么比较C风格字符串的特殊定义。这就是模板特化。

        模板特化（template specialization）的定义为指定一个或多个模板形参的实际类型或实际值。例如可以为Compare模板函数定义一个特化版本。

[cpp] view plain copy print ?
  1. template <> //template关键字后面接空括号   
  2. int Compare(const char * const &x, const char * const &y) //形参为指向常量的常指针的引用   
  3. {  
  4.     return strcmp(x, y);  
  5. }  
template <> //template关键字后面接空括号
int Compare(const char * const &x, const char * const &y) //形参为指向常量的常指针的引用
{
	return strcmp(x, y);
}
        上文简单阐述了模板特化，现在介绍模板特化在STL中的运用，以迭代器中的运用为例。

        迭代器是STL的关键所在，它将原本分开的数据容器和算法很好的胶合在一起。比如下面这个STL中的函数（摘自源码），命名上做了修改，同时略去了一些代码，但是足以说明问题。这个函数通过迭代器交换容器的数据，迭代器是数据容器和算法的桥梁，算法通过数据容器的迭代器访问容器中的数据，而不需关心容器的具体构造。

[cpp] view plain copy print ?
  1. //真正的交换函数，内部调用   
  2. template <class Iter1, class Iter2, class T>  
  3. inline void _iter_swap(Iter1 a, Iter2 b, T) {  
  4.   T tmp = *a;  
  5.   *a = *b;  
  6.   *b = tmp;  
  7. }  
  8. //交换两个迭代器所指的元素，外部接口   
  9. template <class Iter1, class Iter2>  
  10. inline void iter_swap(Iter1 a, Iter2 b) {  
  11.  _iter_swap(a, b, VALUE_TYPE(Iter1)); //VALUE_TYPE返回迭代器的值类型   
  12. }  
//真正的交换函数，内部调用
template <class Iter1, class Iter2, class T>
inline void _iter_swap(Iter1 a, Iter2 b, T) {
  T tmp = *a;
  *a = *b;
  *b = tmp;
}
//交换两个迭代器所指的元素，外部接口
template <class Iter1, class Iter2>
inline void iter_swap(Iter1 a, Iter2 b) {
 _iter_swap(a, b, VALUE_TYPE(Iter1)); //VALUE_TYPE返回迭代器的值类型
}
       上面用到了一个VALUE_TYPE调用，注释说是返回迭代器的值类型，具体如何下文会有介绍。举这个例子，就是为了引出这个调用。本文讲的是模板特化，但是到这里好像已经跑题了，不知所云。铺垫差不多了，进入正题。

       问一个问题，iter_swap这个函数的形参是迭代器，我们需要在函数内部定义一个临时变量，变量的数据类型为迭代器所指的数据类型。那么我们如何知道迭代器所指的数据类型呢？有人说，可以利用模板实参推断机制，解决这个问题。代码如下所示：

[cpp] view plain copy print ?
  1. //真正的交换函数   
  2. template <class Iter1, class Iter2, class T>  
  3. inline void _iter_swap(Iter1 a, Iter2 b, T) {  
  4.   T tmp = *a;  
  5.   *a = *b;  
  6.   *b = tmp;  
  7. }  
  8. //交换两个迭代器所指的元素   
  9. template <class Iter1, class Iter2>  
  10. inline void iter_swap(Iter1 a, Iter2 b) {  
  11.  _iter_swap(a, b, *a); //模板实参推断   
  12. }  
//真正的交换函数
template <class Iter1, class Iter2, class T>
inline void _iter_swap(Iter1 a, Iter2 b, T) {
  T tmp = *a;
  *a = *b;
  *b = tmp;
}
//交换两个迭代器所指的元素
template <class Iter1, class Iter2>
inline void iter_swap(Iter1 a, Iter2 b) {
 _iter_swap(a, b, *a); //模板实参推断
}
        但是如果要推导函数的返回类型，模板实参推断机制就失效了。模板实参推断机制的具体内容，将在本系列（3）中介绍。继续上面的问题，本文用了一个称之为VALUE_TYPE的调用来获取的，它就像是一个萃取剂，萃取出迭代器所指的数据类型。那么它是如何实现的呢？答案就是内嵌型别。在STL中，大多数容器要求定义迭代器的内嵌型别，下面是 list 中的定义，已化简。
[cpp] view plain copy print ?
  1. class MyAlloc{    
  2. };  
  3.   
  4. template<class T>  
  5. struct List_iterator{  
  6.   typedef T value_type;  //list 迭代器的内嵌型别   
  7.   ...  
  8. };  
  9.   
  10. template <class T, class Alloc = MyAlloc>  
  11. class list{  
  12. public:  
  13.   typedef List_iterator<T>  iterator;  //list迭代器   
  14.   ...  
  15. };  
class MyAlloc{  
};

template<class T>
struct List_iterator{
  typedef T value_type;  //list 迭代器的内嵌型别
  ...
};

template <class T, class Alloc = MyAlloc>
class list{
public:
  typedef List_iterator<T>  iterator;  //list迭代器
  ...
};
         通过下面这种方式就可以萃取出 list 迭代器所指的数据类型。
[cpp] view plain copy print ?
  1. template<class I>  
  2. struct Iterator_traits{ //萃取剂定义   
  3.     typedef typename I::value_type value_type;  
  4. };  
  5.   
  6. Iterator_traits<list<int>::iterator>::value_type x = 1;  
template<class I>
struct Iterator_traits{ //萃取剂定义
	typedef typename I::value_type value_type;
};

Iterator_traits<list<int>::iterator>::value_type x = 1;
         这种方式只能萃取出定义了内嵌型别的迭代器，但是如果是原生指针呢，它是没有内嵌型别的？比如 vector 容器，它是用原生指针做迭代器的。定义如下：
[cpp] view plain copy print ?
  1. class MyAlloc{    
  2. };  
  3.   
  4. template <class T, class Alloc = MyAlloc>  
  5. class vector :   
  6. {  
  7. public:  
  8.   typedef T value_type;    //内嵌型别   
  9.   typedef value_type* pointer;  
  10.   typedef const value_type* const_pointer;  
  11.   typedef value_type* iterator;  //vector 迭代器，是原生指针   
  12.   typedef const value_type* const_iterator;  
  13.   typedef value_type& reference;  
  14.   typedef const value_type& const_reference;  
  15.   ...  
  16. };  
class MyAlloc{  
};

template <class T, class Alloc = MyAlloc>
class vector : 
{
public:
  typedef T value_type;    //内嵌型别
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type* iterator;  //vector 迭代器，是原生指针
  typedef const value_type* const_iterator;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  ...
};
       模板特化终于登场了，下面加入了原生指针的支持，使用的正是模板特化技术，在泛化设计中加入了特化版本。该技术也是STL中的核心关键所在。
[cpp] view plain copy print ?
  1. template<class I>  
  2. struct Iterator_traits{  
  3.     typedef typename I::value_type value_type;  
  4. };  
  5. //特化 原生指针   
  6. template<class T>  
  7. struct Iterator_traits<T*>{  
  8.     typedef T value_type;  
  9. };  
  10. //特化 原生常指针   
  11. template<class T>  
  12. struct Iterator_traits<const T*>{  
  13.     typedef T value_type;  
  14. };  
template<class I>
struct Iterator_traits{
	typedef typename I::value_type value_type;
};
//特化 原生指针
template<class T>
struct Iterator_traits<T*>{
	typedef T value_type;
};
//特化 原生常指针
template<class T>
struct Iterator_traits<const T*>{
	typedef T value_type;
};
     下面给出了完整的代码，已在VS2008下测试通过。
[cpp] view plain copy print ?
  1. #include <iostream>   
  2. #include <vector>   
  3. #include <list>   
  4. using namespace std;  
  5.   
  6. //萃取剂   
  7. template<class I>  
  8. struct Iterator_traits{  
  9.     typedef typename I::value_type value_type;  
  10. };  
  11. //特化 原生指针   
  12. template<class T>  
  13. struct Iterator_traits<T*>{  
  14.     typedef T value_type;  
  15. };  
  16. //特化 原生常指针   
  17. template<class T>  
  18. struct Iterator_traits<const T*>{  
  19.     typedef T value_type;  
  20. };  
  21.   
  22. #define VALUE_TYPE(I) Iterator_traits<I>::value_type()   
  23.   
  24. //交换两个迭代器所指的元素   
  25. template <class Iter1, class Iter2>  
  26. inline void iter_swap(Iter1 a, Iter2 b) {  
  27.  _iter_swap(a, b, VALUE_TYPE(Iter1)); //VALUE_TYPE返回迭代器的值类型   
  28. }  
  29. //真正的交换函数   
  30. template <class Iter1, class Iter2, class T>  
  31. inline void _iter_swap(Iter1 a, Iter2 b, T) {  
  32.   T tmp = *a;  
  33.   *a = *b;  
  34.   *b = tmp;  
  35. }  
  36. //测试函数   
  37. int main()  
  38. {  
  39.     int a = 1, b = 2;  
  40.     iter_swap(&a,&b);  
  41.     cout<<a<<' '<<b<<endl;  //2 1   
  42.       
  43.     list<int> l;  
  44.     l.push_back(3);  
  45.     l.push_back(4);  
  46.     iter_swap(l.begin(),++l.begin());  
  47.     cout<<*(l.begin())<<' '<<*(++l.begin())<<endl; //4 3   
  48.   
  49.     Iterator_traits<int *>::value_type w = 5;       //特化   
  50.     Iterator_traits<const int*>::value_type  x = 6; //特化   
  51.         Iterator_traits<vector<int>::iterator>::value_type y = 7; //vector 容器   
  52.     Iterator_traits<list<int>::iterator>::value_type z = 8;   //list 容器   
  53.     cout<<w<<' '<<x<<' '<<y<<' '<<z<<endl; //5 6 7 8   
  54.     return 0;  
  55. }  
#include <iostream>
#include <vector>
#include <list>
using namespace std;

//萃取剂
template<class I>
struct Iterator_traits{
	typedef typename I::value_type value_type;
};
//特化 原生指针
template<class T>
struct Iterator_traits<T*>{
	typedef T value_type;
};
//特化 原生常指针
template<class T>
struct Iterator_traits<const T*>{
	typedef T value_type;
};

#define VALUE_TYPE(I) Iterator_traits<I>::value_type()

//交换两个迭代器所指的元素
template <class Iter1, class Iter2>
inline void iter_swap(Iter1 a, Iter2 b) {
 _iter_swap(a, b, VALUE_TYPE(Iter1)); //VALUE_TYPE返回迭代器的值类型
}
//真正的交换函数
template <class Iter1, class Iter2, class T>
inline void _iter_swap(Iter1 a, Iter2 b, T) {
  T tmp = *a;
  *a = *b;
  *b = tmp;
}
//测试函数
int main()
{
	int a = 1, b = 2;
	iter_swap(&a,&b);
	cout<<a<<' '<<b<<endl;  //2 1
	
	list<int> l;
	l.push_back(3);
	l.push_back(4);
	iter_swap(l.begin(),++l.begin());
	cout<<*(l.begin())<<' '<<*(++l.begin())<<endl; //4 3

	Iterator_traits<int *>::value_type w = 5;       //特化
	Iterator_traits<const int*>::value_type  x = 6; //特化
        Iterator_traits<vector<int>::iterator>::value_type y = 7; //vector 容器
	Iterator_traits<list<int>::iterator>::value_type z = 8;   //list 容器
	cout<<w<<' '<<x<<' '<<y<<' '<<z<<endl; //5 6 7 8
	return 0;
}
         本文介绍模板特化的同时，其实也介绍了STL迭代器实现的另一关键技术——内嵌型别。下文将介绍模板实参推断机制。
      本人享有博客文章的版权，转载请标明出处 http://blog.csdn.net/wuzhekai1985
ljx0305
关注
专栏目录
模板特化
langminglang的博客
03-20 1137
一、为什么要模板特化 特化的概念：所谓特化，就是将泛型的东东搞得具体化一些，从字面上来解释，就是为已有的模板参数进行一些使其特殊化的指定，使得以前不受任何约束的模板参数，或受到特 定的修饰（例如const或者摇身一变成为了指针之类的东东，甚至是经过别的模板类包装之后的模板类型）或完全被指定了下来。 模板为什么要特化： 因为编译器认为，对于特定的类型，如果你能对某一功能更好的实现，那么就该
C++——模板与特化
zy2317878的博客
06-13 944
写在前面 关于模板之前就有所了解，但是一直没有系统整理，而且对特化印象不深，所以借此机会，系统的学习一下模板与特化的相关知识，还望大家多多批评指教。 参考文献： 函数模板和类模板 模版特化 C++模板的特化详解（函数模版特殊，类模版特化） C++模板的偏特化与全特化 重学C++ (十二) 模板特化和偏特化 C++类模板的三种特化 C++ 模板的特化与偏特化 模板显式、隐式实例化和（偏）特化...
STL运用的C++技术（2）——模板特化
wuzhekai的专栏
08-02 5680
STL是C++标准库的重要组成部分之一，它不仅是一个可复用的组件库，更是一个包含算法与数据结构的软件框架，同时也是C++泛型编程的很好例子。STL中运用了许多C++的高级技术。本文介绍了如下技术：模板特化，内嵌型别，参数推导机制。
STL运用的C++技术（1）——成员模板
wuzhekai的专栏
08-02 7550
STL是C++标准库的重要组成部分之一，它不仅是一个可复用的组件库，更是一个包含算法与数据结构的软件框架，同时也是C++泛型编程的很好例子。STL中运用了许多C++的高级技术。本文
STL运用的C++技术（6）——函数对象
wuzhekai的专栏
08-04 1万+
STL是C++标准库的重要组成部分之一，它不仅是一个可复用的组件库，更是一个包含算法与数据结构的软件框架，同时也是C++泛型编程的很好例子。STL中运用了许多C++的高级技术。本文介绍函数对象，其实是接上一篇的话题，因为函数对象本质上还是重载操作符。主要参考了《C++ Pri
C++ 中Traits技术 (3) —— 关于特化和偏特化
decode
04-16 1563
以下面这个例子为例进行说明： template class Test { public: static bool TestFun(const T& t); }; 特化，其实就是为模板参数指定特定类型，分为三种情况：   ① 特化为具体类型        T可以是int string double等类型。如特化为int： template<> class Test {
C++中STL用法超详细总结
热门推荐
一只大笨猫的博客
08-21 20万+
目录 1 什么是STL？ 2 STL内容介绍 2.1 容器 2.2 STL迭代器 2.3 算法 2.4 仿函数 2.4.1 概述 2.4.2 仿函数(functor)在编程语言中的应用  2.4.3 仿函数在STL中的定义 2.5 容器适配器 2.5.1 stack 2.5.2 queue &amp; priority_queue 3 常用容器用法介绍  3.1 vec...
植物大战 模板——C++
最新发布
一些七零八碎的知识点
09-27 5万+
C++模板
STL源码剖析——STL算法stl_algo.h
关注校招求职，微信号：job_campus
09-30 3726
本文剖析的STL算法的源码，在剖析源码的同时会给出一些例子，这样加深对其理解，方便我们对这些算法的使用。
模板的特化
weixin_33804582的博客
04-19 103
提起模板，那我们有必要先了解一下泛型编程。泛型编程：编写与类型无关的逻辑代码，是代码复用的一种手段。模板是泛型编程的基础。模板又分为：类模板和函数模板。首先看类模板的特化：类模板的特化分为：全特化和部分特化。下面举例说明：#include<iostream> usingnamespacestd; template<typenameT1,t...
STL新特性：类模板显式特化详解
在STL入门中，首先要理解的是模板的类模板显式特化（class template explicit specialization）。类模板是一种抽象的定义，它允许程序员创建一系列具有相同接口但不同内部实现的类。通过显式特化，开发者可以在特定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值