C++ 模板特化以及Typelist的相关理解

  近日,在学习的过程中第一次接触到了Typelist的相关内容,比如Loki库有一本Modern C++ design的一本书,大概JD搜了一波没有译本,英文版600多R,瞬间从价值上看到了这本书的价值!!这是题外话。这本书十分经典。其内容对于一个C++新手来说需要时间来理解吸收。在这里记录一下自己的理解。日后发现错误会给予更正。如有有人碰巧看到了。欢迎指正。

参考了http://blog.csdn.net/gatieme/article/details/50953564

整篇内容分了三个部分:1.特化  2.Typelist 3.应用的情形

1.在说明Typelist相关内容之前,要先了解一下什么叫模板特化与模板偏特化。

  1.1 模板与特化:

    模板分为函数模板与类模板。函数模板是一种抽象函数的定义,它代表了具有相同结构的一类函数。类模板类似于Stack等封装区分数据类型,是一种更高级的抽象封装

    所谓特化就是讲泛型的东西更加的具体化,比如在某些泛型参数中进行限定,使得不受任何约定的模板参数受到了约束(比如常见的这个大写T),下面的例子中会更具象化的说明个人的一些理解。

    特化的分类:分为函数模板特化和类模板特化,全特化与偏特化

    ①:函数模板特化

      当函数模板需要对某些类型进行限定的时候称之为函数模板特化

    ②:类模板特化

      与上述类似,只是是使用于类

    ③:全特化

      将模板中的参数全部指定为确定的类型,其标志就是应用于完全确定的内容。而不是在编译时去确定具体的应用实例。标志:template<>然后是和末班类型没有关系的类实现或者函数定义。

    ④:偏特化

      模板中的参数没有被全部指定。需要编译器在编译时进行确定。

  1.2 函数模板特化:

    如下代码:

template <class T>
int compare(const T  left,const T  right) {
    std::cout << "test template func" << endl;
    return (left - right);
}

这个函数能够满足一些基本类型的比较需求(int,float,....巴拉巴啦),但是对于字符串的比价这个函数是不能支持的。

因此我们可以对其进行特化处理。

template < >
int compare<const char *>(const char * left,const char * right) {
    std::cout << "function tempate special" << std::endl;
    return strcmp(left,right);
}

//另一种特化方式是如下
template < >
int compare(const char * left,const char * right) {
  std::cout << " in special template <> .." << std::endl;
  return strcmp(left,right);
}

测试代码:

#include<bits/stdc++.h>

template <class T>
int compare(const T  left,const T  right) {
    std::cout << "test template func" << std::endl;
    return (left - right);
}

template <>
int compare(const char* left, const char* right){
    std::cout <<"in special template..." <<std::endl;
    return strcmp(left, right);
}


int main() {
    std::cout << compare(1, 2) << std::endl;
    const char *left = "abcd";
    const char *right = "accd";
    std::cout << compare(left, right) << std::endl;
    return 0;
}

输出内容

test template func
-1
in special template...
-1

函数的特化,当函数调用发现有特化后的匹配函数的时候,会优先调用特化的函数。而不是通过函数模板进行实例化。

 

  1.2类模板特化

    与函数模板特化类似,当模板内需要对某些类型进行特别处理时,需要这种处理。这里归纳了一个模板参数的类模板特化的几种类型。

    1.绝对类型

    2.引用,指针类型

    3. 特化为另一个类模板(这个厉害了,我猜的)

  1.2.1 特化为绝对类型 : 直接为某个特定类型做特化,这是一种常见的方式。

    

#include <iostream>
#include <cstring>
#include <cmath>

template <class T>
class Compare {
public : 
    static bool IsEqual(const T & lh,const T & rh) {
        std::cout << "uniusall " << std::endl;
        return lh == rh;
    }
};

template<>
class Compare<float> {
public :
    static bool IsEqual(const float & lh,const float & rh) {
        std::cout << "float special class " << std::endl;
        return abs(lh - rh) < 1e-4;
    }
};

int main() {
    Compare<int> comp1;
    std::cout << comp1.IsEqual(2,3) << std::endl;
    Compare<float> comp2;
    std::cout << comp2.IsEqual(1,1) << std::endl;
}

另外我特意要说明的是,如果没有第一段template<class T>的模板声明,直接template<> Class Compare<float>是否可以?

这个是不可以的,编译报错内容是 'Compare' is not a class template,这个在后边有关typelist内容中也会提出(ps 主要是由在阅读Typelist中的一行代码导致我特意测试了一下这种情况)。

偏特化:

template <class T1,class T2>
class A {};

template <class T1>
class A<T1,int> {};

下面的代码框内容是在另一个博客中提到的另外2中类型,目前还没有使用过。作为记录放在这里

template <class _Iterator>
struct iterator_traits {
  typedef typename _Iterator::iterator_category iterator_category;
  typedef typename _Iterator::value_type        value_type;
  typedef typename _Iterator::difference_type   difference_type;
  typedef typename _Iterator::pointer           pointer;
  typedef typename _Iterator::reference         reference;
};

// specialize for _Tp*
template <class _Tp>
struct iterator_traits<_Tp*> {
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp                         value_type;
  typedef ptrdiff_t                   difference_type;
  typedef _Tp*                        pointer;
  typedef _Tp&                        reference;
};

// specialize for const _Tp*
template <class _Tp>
struct iterator_traits<const _Tp*> {
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp                         value_type;
  typedef ptrdiff_t                   difference_type;
  typedef const _Tp*                  pointer;
  typedef const _Tp&                  reference;
};
// specialize for T*
template<class T>
class Compare<T*>
{
public:
    static bool IsEqual(const T* lh, const T* rh)
    {
        return Compare<T>::IsEqual(*lh, *rh);
    }
};

 

这种特化其实是不一种绝对的特化,他只是对类型做了某些限定,但仍然保留了莫版型,给我们提供了极大地方便。

在这里,我么不就不需要对int*.float *,double *等等类型分别做特定的特化。这其实是第二种方式的扩展,其实夜视对类型做了某种限定。而不是绝对化为某个具体类型。

如下一段代码

template <class T>
class Compare< vector<T> > {
public :
    static bool IsEqual(const vector<T> &lh,const vector<T> & rh) {
        if (lh.size() != rh.size()) return false;
        else {
            for (int i = 0 ; i < lh.size() ; i++)
                if (lh[i] != rh[i]) return false;
        }
    }
};

上述的代码比较好理解。就省略了

 

以下是第三种特化为另一个类模板

template <class T1>
struct SpecializedType {
    T1 x1;
    T1 x2;
}

template <class T>
class Compare< SpeciallizedType<T> > {
public :
    static bool IsEqual(const Specialized<T> & lh,const Specialized<T>&rh) {
        return Compare<T>::IsEqual(lh.x1 + lh.x2,rh.x1 + rh.x2);
    }
};

SpecializedType<float> a = {10.0f,10.1f};
SpecializedType<float> b = {10.3f,10.4f};
bool flag = Compare<SpecializedType<float> >::IsEqual(a,b);

 

2.关于TypeList,这个是来自于Loki库中的一部分。

基于个人的理解。我分开一段一个一个函数的记录一下。

首先是一些最基本的定义和宏

class NullType {};
template <class T,class U>
struct Typelist {
    typedef H Head;
    typedef U Tail;
}
//通过定义一些宏使得typelist线性化
#define TYPELIST_0() NullType  
#define TYPELIST_1(T1) Typelist<T1,TYPELIST_0()>  
#define TYPELIST_2(T1,T2) Typelist<T1,TYPELIST_1(T2)>  
#define TYPELIST_3(T1,T2,T3) Typelist<T1,TYPELIST_2(T2,T3)>  
#define TYPELIST_4(T1,T2,T3,T4) Typelist<T1,TYPELIST_3(T2,T3,T4)>  
#define TYPELIST_5(T1,T2,T3,T4,T5) Typelist<T1,TYPELIST_4(T2,T3,T4,T5)>  

Typelist结构里面是2个typedef,看见其内部没有任何数值,他们的实体是空的,不含有任何状态,也未定义任何函数。执行期间Typelists也不带任何数值,他们的存在只是为了携带类别信息,Typelist并未打算被具体化。 另外规定,typelist必须以NullType作为结尾。其可以被视为一个结束符号。具体宏的作用结合下面的例子来说明。

//如何声明使用
typedef TYPELIST_0() TL0;
typedef TYPELIST_3(char,int,double) TL3;
将上面的宏产开后
是如下的形式

typedef NullType TL0;
typedef Typelist<char,Typelist<int,Typelist<double,NullType> > >TL3;

上面这种方法利用了特化中的特化为另一个模板的方法。

针对于上面的展开,可以看下获取长度length的代码

//为了方便解释,我把他们分为3部分.
//第一部分 只有一行
template<class TList>struct Length;
//第二部分
template<>struct Length<NullType> {
    enum { value = 0; }
};
//第三部分
template<class T,class U>
struct Length<Typelist<T,U> > {
    enum { value = 1 + Length<U>::value} ;
};

分开来解释一个我个人的理解:

第一部分:template<class TList>struct Length;

这句话实际上是最困扰我的一句话,首先这句话一定要有。否则的代价是编译不过。

关于这句话的作用个人的理解第一:基于编译是否通过,如果使用全特化,必然要有“前置的模板声明”,否则会报错

                                        第二:首先说明这个获取长度的方法该如何调用。基于前面讲的TL3

std::cout<<Length<TL0>::value<<std::endl;

借助这个调用来解释我个人的理解,在Length中,只有NullType和Typelist<T,U>可以进行匹配,当我们尝试传递Length<int>的时候自然是无法找到匹配, 原因是Length进行特化的时候只能匹配到NullType和Typelist,

由此,这句话既是声明又是一种限定,他告诉编译器什么形式的具象化可以匹配模板。

第二个部分:

  全特化,只有NullType可以匹配,递归调用的终点。很好理解

第三个部分:

  偏特化,结合前面的宏展开,可以看出其递归调用的方式。其使用Typelist来进行特化,需要2个参数。

 

剩下的代码大体只是逻辑区别:不再赘述,完整代码:(来自http://blog.csdn.net/zhuyingqingfen/article/details/43938713)

#ifndef TYPE_LISTS_H_
#define TYPE_LISTS_H_


#include <iostream>
#include <string>
#include "typetraits.h"

/*
TypeLists 内部没有任何数值(value),他们的实体是空的,不含有任何状态,也未定义任何函数。
执行期间TypeLists也不带任何数值,他们存在的理由只是为了携带型别信息。TypeLists 并未打算被具
现化。因此,当我们说“a TypeListL”,实际指的是一个typelist型别,不是一个typelist 对象。
规定 typelist 必须以NullType(类)结尾,NullType可被视为一个结束符号,类似于c字符串的\0功能,
定义一个只有一个元素的typelist如下:
typedef Typelist<int,NullType> OneTypeOnly.
*/
template<class T,class U>
struct Typelist
{
    typedef T Head;
    typedef U Tail;
};
Class NullType{};
//通过定义宏 将typelist线性化
#define TYPELIST_0() NullType
#define TYPELIST_1(T1) Typelist<T1,TYPELIST_0()>
#define TYPELIST_2(T1,T2) Typelist<T1,TYPELIST_1(T2)>
#define TYPELIST_3(T1,T2,T3) Typelist<T1,TYPELIST_2(T2,T3)>
#define TYPELIST_4(T1,T2,T3,T4) Typelist<T1,TYPELIST_3(T2,T3,T4)>
#define TYPELIST_5(T1,T2,T3,T4,T5) Typelist<T1,TYPELIST_4(T2,T3,T4,T5)>

//计算TypeList长度
//大多数Typelist的操作都是基于递归,递归终止条件通过模板特化实现。
template<class TList>struct Length;
template<>struct Length<NullType>//Length的全特化,即,只匹配NullType。
{
    enum{value = 0};
};
template<class T,class U>
struct Length<Typelist<T,U> >//Length的扁特化,可匹配任何TypeList<T,U>类型,包括U同时也是Typelist的复合情况。
{
    enum{value = 1+Length<U>::value};
};
//2 索引式访问
template <class TList,unsigned int index> struct TypeAt;
template<class Head,class Tail>
struct TypeAt<Typelist<Head,Tail>,0>
{
    typedef Head Result;
};
template<class Head,class Tail,unsigned int i>
struct TypeAt<Typelist<Head,Tail> ,i>
{
    typedef typename TypeAt<Tail,i-1>::Result Result;
};

//类似TypeAt功能,不过TypeAtNonStrict对逾界访问更加宽容。
//比如TypeList的个数是3,那么你不能使用TypeAt<TL3,3>::Result,这样会编译错误。
//但是TypeAtNonStrict<TL3,3,NullType>::Result可以,如果不存在索引为3的type,那么结果是第三个引数即NullType
template <class TList, unsigned int i, typename DefType = NullType>
struct TypeAtNonStrict
{
    typedef DefType Result;
};
template <class T, class U, typename DefType>
struct TypeAtNonStrict< Typelist<T, U>, 0, DefType >
{
    typedef T Result;
};
template <class T, class U, unsigned int i, typename DefType>
struct TypeAtNonStrict< Typelist<T, U>, i, DefType >
{
    typedef typename TypeAtNonStrict<U, i - 1, DefType>::Result Result;
};

//3 查找TypeList
template<class TList,class T> struct IndexOf;//声明
template<class T>
struct IndexOf<NullType,T>//如果TList为NullType,那么令value = -1;
{
    enum{value = -1};
};
template<class Tail,class T>
struct IndexOf<Typelist<T,Tail> ,T>//如果T是TList中的头端,那么令value= 0;
{
    enum{value = 0};
};
template<class Head,class Tail,class T>//将IndexOf施于TList尾端和T,并将结果置于一个临时变量temp
struct IndexOf<Typelist<Head,Tail> ,T>//如果temp为-1,令value为-1,否则令value为1+temp
{
private:
    enum{temp = IndexOf<Tail,T>::value};//temp要先于value声明定义。
public:
    enum{value = temp == -1 ? -1 : temp + 1};
};

//4 附加元素到typelist
template <class Tlist,class T>struct Append;//声明
template<>struct Append<NullType,NullType>//如果TList是NULL而且T是NULL,那么令Result为NullType
{
    typedef NullType Result;
};
template <class T> struct Append<NullType,T> //如果TList是NullType,且T是type(非typelist),
{                                           //那么Result将是"只含有唯一元素的T";
    typedef TYPELIST_1(T) Result;
};
template <class Head,class Tail>
struct Append<NullType,Typelist<Head,Tail> >// 如果TList是NullType,且T是一个typelist,那么Result便是T本身
{
    typedef Typelist<Head,Tail> Result;
};
template<class Head,class Tail,class T>//否则,如果Tlist是non-null,那么result将是个typelist,以TList::Head
struct Append<Typelist<Head,Tail>,T>   //为起头端,并以T附加到TList::Tail的结果为其尾端。
{
    typedef Typelist<Head,typename Append<Tail,T>::Result> Result;
};

//5 Reverse
template <class TList> struct Reverse;
template <>struct Reverse<NullType>
{
    typedef NullType Result;
};
template <class Head, class Tail>
struct Reverse< Typelist<Head, Tail> >
{
    typedef typename Append<
        typename Reverse<Tail>::Result, Head>::Result Result;
};


#endif

调用测试代码:

void typelists_test()
{
    typedef TYPELIST_0() TL0;
    typedef TYPELIST_3(char,int,double) TL3;
    typedef TYPELIST_3(char,int,double) TL3_1;
    //Length
    std::cout<<Length<TL0>::value<<std::endl;
    std::cout<<Length<TL3>::value<<std::endl;

    //TypeAt
    typedef TypeAt<TL3,0>::Result Parm1;
    typedef TypeAt<TL3,1>::Result Parm2;
    typedef TypeAt<TL3,2>::Result Parm3;

    typedef TypeAtNonStrict<TL3,3,EmptyType>::Result TEST_TYPE;

    std::cout<<"Parm1 Type:"<<typeid(Parm1).name() <<" sizeof : "<< sizeof(Parm1)<<std::endl;
    std::cout<<"Parm2 Type:"<<typeid(Parm2).name() <<" sizeof : "<< sizeof(Parm2)<<std::endl;
    std::cout<<"Parm3 Type:"<<typeid(Parm3).name() <<" sizeof : "<< sizeof(Parm3)<<std::endl;
    std::cout<<"TEST_TYPE Type:"<<typeid(TEST_TYPE).name() <<" sizeof : "<< sizeof(TEST_TYPE)<<std::endl;

    //IndexOf
    std::cout<<"char indexof TL3 :"<<IndexOf<TL3,char>::value<<std::endl;
    std::cout<<"int indexof TL3 :"<<IndexOf<TL3,int>::value<<std::endl;
    std::cout<<"float indexof TL3 :"<<IndexOf<TL3,float>::value<<std::endl;

    //Append 
    typedef Append<TL3,int> TL4;//TL4不是一个TypeList
    typedef Append<TL3_1,TYPELIST_2(float,double)> TL5;
    std::cout<<"TL4 Length  :"<<Length<TL4::Result>::value<<std::endl;
    std::cout<<"TL5 Length  :"<<Length<TL5::Result>::value<<std::endl;

    //Reverse
    std::cout<<"Reverse result:"<<typeid(Reverse<TL3>::Result).name()<<std::endl;
}

 

3.应用

  举例:大学绩点计算,众所周知的这是一个基于权重的计算方法,对于不同学分的学科权重不同。现在假设有4科目吧:信号,电磁场,高频,微波器件

那么可能的实现方式是这样的:(PS觉得这个例子不太恰当甚至十分不恰当,仅作为个人辅助理解。)

①:直接计算

//伪代码
if (当前的科目是信号) {
    信号科目相关加权和分数处理...
}
if (当前的科目是电磁场) {
    电磁场科目相关加权和分数处理...
}
//剩下的略

②:利用类和继承来实现。

  第一种的实现很直接却脱离了面向对象的设计,显得代码十分多,乱。

  第二种大体代码就像下面,在这里创建了对应的实例化对象进行处理。

#include<bits/stdc++.h>
using namespace std;

class ScoreBase {
public :
    ScoreBase() {}
    virtual int calcuWeight(score * scores);
    virtual ~ScoreBase() {}
}

class ScoreSignal : public ScoreBase {
public :
    ScoreSignal(){}
    virtual int calcuWeight(score * scores);
}

class ScoreElect : public ScoreBase {
public :
    ScoreElect() {}
    virtual int calcuWeight(score * scores);
}

vector<ScoreBase *>dealscore;
dealscore.push_back(new ScoreSignal());
dealscore.push_back(new ScoreElect());
score * scores = get_scores();//获取到了分数
int totalWeight = 0; for (int i = 0 ; i < (int)dealscore.size() ; i++) totalWeight += dealscore[i] -> calcuWeight(scores);

③:使用typelist完成这件事情

记得之前的展开宏么,这就可以使用到它了。为了方便,我们用结构体(纯粹是因为默认public,关于在C++中struct和class的区别,http://www.cnblogs.com/Commence/p/7481315.html)

第一步先通过宏定义出我们想要的东西

struct signalscore {
    int static calcuWeight(score * scores);
}

struct elecscore {
    int static calcuWeight(score * scores);
}

struct highfreqscore {
    int static calcuWeight(score * scores);
}

typedef Typelist<signalscore,Typelist<elecscore,Tyeplist<highfreqscore,NullType> > >calWeightList;

第二步:类似前面获取Length的方法,建立模板来处理它。

template<class TList>struct calWeight;
template<>struct calWeight<NullType> {
    int static calcuWeight(scene * scenes) { return 0;}
}

template<class T,class U>
struct calWeight< Typelist<T,U> > {
    int static calWeight(scene * scenes) {
        return T::calcuWeight(scene * scenes) + calWeight<U>::calWeight(scene * scenes);
    }
}

std::cout << calWeight<calWeightList>::calWeight(scenes) << std::endl;

由于时间关系:上述第三种并没有完整的可以编译通过的代码。将在近期补充

posted @ 2017-09-17 23:06  Commence  阅读(1838)  评论(0编辑  收藏