解读C++编程中类模板的三种特化

1.类模板显式特化
为了进行特化,首先需要一个通用的版本,称主模板.主模板使用了标准库堆算法.  堆 是一种线性化的树形结构,将一个值压入一个堆中, 实际上等于将该值插入到一个树形结构中;将一个值从堆中取出就等于移除并返回堆中最大值.但在处理字符的指针时会碰钉子.堆将按照指针的值进行组织. 我们可以提供一个显式特化版本解决此问题(例1)如果希望除了一个针对const char*的Heap外,还希望提供一个针对char *的Heap;(例2)

//主模板
template <typename T>
class Heap
{
private:
  std::vector<T> h_;
public:
  void push(const T& val);
  T pop();
  bool empty() const //const声明在末尾表示该函数不能修改类变量
  {
    return h_.empty();
  }
}

template <typename T>
void Heap<T>::push(const T& val)
{
  h_.push_back(val);
  std::push_heap(h_.begin(),h_.end());
}

template <typename T>
T Head<T>::pop()
{
  std::pop_head(h_.begin(),h_.end());
  T tmp(h_.back());
  h_.pop_back();
  return tmp;
}

例1

//显示特化版本
/***********************************************
 *     可以看到模板参数列表是空的,其实这根本不是一个模
 *  板. 因为没有指定任何模板参数.所以模板的显式特化又被
 *  称作"完全特化".
 *     Heap<const char*> 完全特化,不会导致模板的实例化;
 *     Heap<int> 特化,会导致模板的实例化;
 *     编译器根据主模板的声明来检查类模板特化.
***********************************************/
template<>//注意,无任何参数,当然,它本来就不是一个模板
class Head<const char *>
{
private:
  std::vector<const char *> h_;
public:
  void push(const char *pval);
  const char * pop();
  bool empty() const //const声明在末尾表示该函数不能修改类变量
  {
    return h_.empty();
  }
};
//再次提醒, Head<const char *>不是一个模板
void Heap<const char*>::push(const char *pval)
{
  h_.push_back(pval);
  std::push_heap(h_.begin(),h_.end());
}

例2

/***********************************************
 *     C++没有要求显式特化的接口必须和主模板的接口完全
 *  匹配.如该例中,没有定义主模板的empty函数,并且自行增加
 *  了size和capitalize两个函数.
 *     提醒:此例中不定义empty函数是不可取的,定义模板的
 *  显式特化和类的派生之间虽然不存在任何技术上的联系,但
 *  是用户依然可以参考类的派生的优点,让特化版本至少具有
 *  主模板的基本能力.
***********************************************/
template<>//注意,无任何参数,当然,它本来就不是一个模板
class Head<char *>
{
private:
  std::vector<char *> h_;
public:
  void push(char *pval);
  char * pop();
  //注意,此处没有提供empty函数哟!!!
  size_t size() const;
  void capitalize();
};

2.模板局部特化
模板局部特化首先要声明的是,C++还不支持对函数模板的局部特化,所以此处我们只讨论类模板的局部特化.我们依然首先需要一个主模板.(参考类模板显式特化) 自我理解:如果针对不能的指针定义不同的完全特化,岂不是太麻烦了,有没有更好的办法呢?那就是局部特化了.(例1)提示: 局部特化它是一个模板.完全特化不是一样模板.

例1

/***********************************************
 *  局部特化
 *     和完全特化不同,这里的Heap参数类型只是被部分的确
 *  定为T*,而T是一个未指定的类型,这就是为什么说它是局部
 *  特化的原因;
 *     当使用一个未经任何修饰的指针类型来实例化Heap时,
 *  局部特化将优先于主模板;
 *     当使用const char * 或 char *(参考类模板显式特化)来
 *  实例化Heap时,此时完全特化又会优先于局部特化.
 *  Heap<std::string> h1;  主模板  T是std::string
 *  Heap<std::string *> h2;  局部特化  T是std:string
 *  Heap<int **> h3;    局部特化 T是int *
 *  Heap<char *> h4;  完全特化 T是char *
 *  Heap<const int *> h5;  局部特化 T是const int
 *  Heap<int (*)()> h6;  局部特化 T是int()
***********************************************/
template <typename T>
class Heap<T *> //注意这里
{
private:
  std::vector<T *>h_;
public:
  void push(const T *val);
  T *pop();
  bool empty()
  {
    return h_.empty();
  }
};

template <typename T>
void Heap<T *>::push(const T *val)
{
  //......
}

例2

/***********************************************
 *     有一点很微妙但很有用:主模板的完全特化或局部特化
 *  必须采用与主模板相同数量和类型的实参进行实例化,但它
 *  的模板的参数并不需要具有和主模板相同的形式.
***********************************************/
//定义一个模板,有三个模板参数,书写形式如下
template <typename R,typename A1,typename A2>
//注意,局部特化中,模板参数也是三个,但书写形式可不一样喽
class Heap<R (*) (A1,A2)>
{
  //......
};

Heap<char *(*) (int,int)> h7; //R是char *,A1和A2是int
//把 char *(*) (int,int) 想象成一个"指向有两个参数的非成员函数的指针"

template <class C,typename T>
class Heap<T C::*>
{
  //......
};
Heap<std::string Name::*> h8;//T是string,C是Name

尽管为何需要对这些东西使用Heap只是一个猜测,先知道有这么一用法吧!

3.类模板成员特化

虽然模板的特化和类的派生之间没有任何关系, 但在特化模板的时候,不妨借鉴一下派生的精神.也就意味着一个完全特化或局部特化通常必须重新实现 主模板具备的所有能力.
例:

//主模板
template <typename T>
class Heap
{
private:
  std::vector<T> h_;
public:
  void push(const T& val);
  T pop();
  bool empty() const //const声明在末尾表示该函数不能修改类变量
  {
    return h_.empty();
  }
}
//其实我们真正需要特化的是 push 和 pop两个函数.
//对比显式特化,它是通过主模板,再写一个模板显式特化版本类;
//而这里只是对类模板成员进行了单独特化.
template<>
void Heap<const char*>::push(const char *const &pval)
{
  h_.push_back(pval);
  std::push_heap(h_.begin(),h_.end(),strLess);
}

template<>
const char* Heap<const char*>::pop()
{
  std:pop_heap(h_.begin(),h_end(),strLess);
  const char* tmp = h_.back();
  h_.pop_back();
  return tmp;
}

注意,这些函数的接口必须和 "它们正在特化其成员" 的模板的相应接口相匹配.如例1, 就得和主模板的接口相匹配.而如果你是自己再定义的一个显式/局部特化版本类,就不需要匹配 一致.(见显式特化和局部特化),最后指出两点: 首先,除了成员函数外,其实成员也可以被显式特化,如静态成员和成员模板.其次,显式特化是为模板或模板成员提供定制版本的一种手段;而显式实例化仅仅是明确地告诉编译器去实例化一个成员.

时间: 2016-01-05

详解C++编程中类模板的相关使用知识

有时,有两个或多个类,其功能是相同的,仅仅是数据类型不同,如下面语句声明了一个类: class Compare_int { public : Compare(int a,int b) { x=a; y=b; } int max( ) { return (x>y)?x:y; } int min( ) { return (x<y)?x:y; } private : int x,y; }; 其作用是对两个整数作比较,可以通过调用成员函数max和min得到两个整数中的大者和小者. 如果想对两个浮点数(

C++函数模板与类模板实例解析

本文针对C++函数模板与类模板进行了较为详尽的实例解析,有助于帮助读者加深对C++函数模板与类模板的理解.具体内容如下: 泛型编程(Generic Programming)是一种编程范式,通过将类型参数化来实现在同一份代码上操作多种数据类型,泛型是一般化并可重复使用的意思.泛型编程最初诞生于C++中,目的是为了实现C++的STL(标准模板库). 模板(template)是泛型编程的基础,一个模板就是一个创建类或函数的蓝图或公式.例如,当使用一个vector这样的泛型类型或者find这样的泛型函数

C++中的类模板详解及示例

C++中的函数模板 对于类的声明来说,也有同样的问题.有时,有两个或多个类,其功能是相同的,仅仅是数据类型不同,如下面语句声明了一个类: 复制代码 代码如下: class Compare_int{ public:  Compare(int a,int b)  {   x=a;   y=b;  }   int max()  {   return (x>y)?x:y;  }  int min()  {   return (x<y)?x:y;  } private:  int x,y;}; 其作用是

C++类模板与模板类深入详解

1.在c++的Template中很多地方都用到了typename与class这两个关键字,而且有时候二者可以替换,那么是不是这两个关键字完全一样呢? 事实上class用于定义类,在模板引入c++后,最初定义模板的方法为:template<class T>,这里class关键字表明T是一个类型,后来为了避免class在这两个地方的使用可能给人带来混淆,所以引入了typename这个关键字,它的作用同class一样表明后面的符号为一个类型,这样在定义模板的时候就可以使用下面的方式了:      t

MySQL中Decimal类型和Float Double的区别(详解)

MySQL中存在float,double等非标准数据类型,也有decimal这种标准数据类型. 其区别在于,float,double等非标准类型,在DB中保存的是近似值,而Decimal则以字符串的形式保存数值. float,double类型是可以存浮点数(即小数类型),但是float有个坏处,当你给定的数据是整数的时候,那么它就以整数给你处理.这样我们在存取货币值的时候自然遇到问题,我的default值为:0.00而实际存储是0,同样我存取货币为12.00,实际存储是12. 幸好mysql提供

C++聚合关系类的构造函数的调用顺序详解

如图,表示一个聚合关系 下面就用简单的代码来实现 #pragma once class Engine { public: Engine(); ~Engine(); }; Engine.h #include <iostream> #include "Engine.h" using namespace std; Engine::Engine() { cout << "调用构造函数:Engine()" << endl; } Engine

java 中枚举类enum的values()方法的详解

java 中枚举类enum的values()方法的详解 前言: 关于枚举,相信使用的已经很普遍了,现在主要写的是枚举中的一个特殊方法,values(), 为什么说特殊呢,因为在Enum 的 API 文档中也找不到这个方法.接下来就看看具体的使用. 理论上此方法可以将枚举类转变为一个枚举类型的数组,因为枚举中没有下标,我们没有办法通过下标来快速找到需要的枚举类,这时候,转变为数组之后,我们就可以通过数组的下标,来找到我们需要的枚举类.接下来就展示代码了. 首先是我们自己的枚举类. public e

PHP验证码类文件及调用方式代码详解

代码如下所示: //验证码类 class ValidateCode { private $charset = 'abcdefghkmnprstuvwxyzABCDEFGHKMNPRSTUVWXYZ23456789';//随机因子 private $code;//验证码 private $codelen = 4;//验证码长度 private $width = 130;//宽度 private $height = 50;//高度 private $img;//图形资源句柄 private $fon

C++ 类的继承与派生实例详解

 C++ 类的继承与派生实例详解 继承性是面向对象程序设计最重要的特性之一,使软件有了可重用性,C++提供的类的继承机制. 继承与派生的概念 一个新类从已有的类那里获得已有的特性,这种现象称为类的继承.同样也可以说成已有的类派生出来了新的类.类A继承自类B也就是类B派生了类A.所以继承和派生的关系就像小学时把字句和被字句的造句一样.有了继承与派生后,就有了父类/基类与子类/派生类,C++中将类B称为父类/基类,将类A称为子类/派生类. 派生类的声明: #include <iostream> u

浅谈C++ 类的实例中 内存分配详解

一个类,有成员变量:静态与非静态之分:而成员函数有三种:静态的.非静态的.虚的. 那么这些个东西在内存中到底是如何分配的呢? 以一个例子来说明: #include"iostream.h" class CObject { public: static int a; CObject(); ~CObject(); void Fun(); private: int m_count; int m_index; }; VoidCObject::Fun(){ cout<<"Fu

Python类的继承和多态代码详解

Python类的继承 在OOP(ObjectOrientedProgramming)程序设计中,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类.父类或超类(Baseclass.Superclass). 我们先来定义一个classPerson,表示人,定义属性变量name及sex(姓名和性别): 定义一个方法print_title():当sex是male时,printman:当sex是female时,prin

对angular 实时更新模板视图的方法$apply详解

有的时候在回调里面写了更新scope的里面的内容,视图上面竟然没有同时更新,这就用到了$apply Scope的特性 接下来,看看Scope有哪些特性呢? Scope提供$watch方法监视Model的变化. Scope提供$apply方法传播Model的变化. Scope可以继承,用来隔离不同的application components和属性访问权限. Scope为Expressions的计算提供上下文. 最简单的使用方法,就是在需要传递变化的地方写上以下代码 $scope.$apply()

基于模板引擎Jade的应用(详解)

有用的符号: | 竖杠后的字符会被原样输出 · 点表示下一级的所有字符都会被原样输出,不再被识别.(就是|的升级版,实现批量) include 表示引用外部文件 短杠说明后面跟着的字符只是一段代码(与|的区别就是,|后面的内容会被显示,而短杠后面的内容直接不显示了!) 例子: js: const jade = require('jade'); console.log(jade.renderFile('./xxx.jade',{pretty:true,name:'singsingasong'}))

对python实现模板生成脚本的方法详解

最近项目需要,针对主项目提取一个小的基础版本,供于在新建项目时使用,所以就有这个python模板生成脚本,其作用如下: 1.通过配置文件来控制模板中的数据.格式化的过滤条件 2.执行后会把目录下所有的文件都会执行一篇 #!/usr/bin/python #encoding: utf-8 import json import codecs import os def get_files(root_path): for dir in os.walk(root_path): if dir[2]: fo