Modern C++ Design(MCD)学习笔记 && 测试代码

converse

困的不行，先把测试代码放上来，有兴趣的自己可以编译运行看看，gcc,vc7均编译通过了

/********************************************************************
        created:        2007-2-7
        filename:         typelists.cpp
        author:                Lichuang
       
        purpose:       
*********************************************************************/

#include <iostream>

// 表示类型链表中的最后一位,相当于字符串中最后的'\0'
class NullType {};

// 头类型和尾类型都是模板
template <class T, class U>
struct Typelist
{
        typedef T Head;
        typedef U Tail;
};

#define TYPELIST_1(T1) Typelist<T1, NullType>

// 根据传入的模板参数生成一个类型链表,注意默认类型是NullType
template<typename T1 = NullType, typename T2 = NullType, typename T3 = NullType>
struct MakeTypelist
{
private:
        typedef typename MakeTypelist<T2, T3>::Result TailResult;

public:
        typedef Typelist<T1, TailResult> Result;
};

// 对没有模板参数的偏特化类定义
template<>
struct MakeTypelist<>
{
        typedef NullType Result;
};

/********************************************************************
        返回typelist长度的模板类,递归思想的美妙体现
*********************************************************************/
template <class TList>
struct Length;

//
template <class T, class U>
struct Length< Typelist<T, U> >
{
        static const int value = 1 + Length<U>::value;
};

// 对于NullType返回0,这是起始情况
template <>
struct Length<NullType>
{
        static const int value = 0;
};

/********************************************************************
        根据index返回在一个typelist中位于这个index的类型,index从0开始
*********************************************************************/
template <class TList, int index>
struct TypeAt
{
        typedef typename TypeAt<typename TList::Tail, index - 1>::Result Result;
};

template <class Head, class Tail>
struct TypeAt<Typelist<Head, Tail>, 0>
{
        typedef Head Result;
};

/********************************************************************
        根据typelist中的类型返回index,index从0开始
*********************************************************************/
template<class TList, class T>
struct IndexOf
{
private:
        static const int temp = IndexOf<typename TList::Tail, T>::value;

public:
        static const int value = (temp == -1 ? -1 : 1 + temp);
};

// 对于Typelist中的Tail返回0
template <class T, class Tail>
struct IndexOf<Typelist<T, Tail>, T>
{
        static const int value = 0;
};

// 对nulltype返回-1
template <class T>
struct IndexOf<NullType, T>
{
        static const int value = -1;
};

/********************************************************************
        添加一个类型到typelist的后面
*********************************************************************/
template <class TList, class T>
struct Append;
// 在typelist中一直查找nulltype下去,找到的时候就把类型添加进去返回
template <class Head, class Tail, class T>
struct Append<Typelist<Head, Tail>, T>
{
        typedef Typelist<Head, typename Append<Tail, T>::Result> Result;
};

template <class Head, class Tail>
struct Append<NullType, Typelist<Head, Tail> >
{
        typedef Typelist<Head, Tail> Result;
};

template <class T>
struct Append<NullType, T>
{
        typedef TYPELIST_1(T) Result;
};

template <>
struct Append<NullType, NullType>
{
        typedef NullType Result;
};

/********************************************************************
        移除typelist中某个类型的第一次出现
*********************************************************************/
// 当head == T的时候,这个查找过程结束,返回Tail
// 否则将一直查找下去
template<class TList, class T>
struct Erase
{
        typedef Typelist<typename TList::Head, typename Erase<typename TList::Tail, T>::Result> Result;
};

template <class T, class Tail>
struct Erase<Typelist<T, Tail>, T>
{
        typedef Tail Result;
};

template <class T>
struct Erase<NullType, T>
{
        typedef NullType Result;
};

template<class TList, class T>
struct EraseAll
{
        typedef Typelist<typename TList::Head,
                typename EraseAll<typename TList::Tail, T>::Result> Result;
};

/********************************************************************
        移除typelist中某个类型的所有出现
*********************************************************************/
template <class T, class Tail>
struct EraseAll<Typelist<T, Tail>, T>
{
        typedef typename EraseAll<Tail, T>::Result Result;
};

template <class T>
struct EraseAll<NullType, T>
{
        typedef NullType Result;
};

/********************************************************************
        移除typelist中某个类型的重复出现,只留下最开始的一个
*********************************************************************/
template <class TList>
struct NoDuplicates;

template <class Head, class Tail>
struct NoDuplicates< Typelist<Head, Tail> >
{
private:
        typedef typename NoDuplicates<Tail>::Result L1;
        typedef typename Erase<L1, Head>::Result L2;

public:
        typedef Typelist<Head, L2> Result;
};

template <>
struct NoDuplicates<NullType>
{
        typedef NullType Result;
};

/********************************************************************
        把typelist中某个类型替换为另一个类型
*********************************************************************/
template<class TList, class T, class U>
struct Replace
{
        typedef Typelist<typename TList::Head, typename Replace<typename TList::Tail, T, U>::Result> Result;
};

template <class T, class Tail, class U>
struct Replace<Typelist<T, Tail>, T, U>
{
        typedef Typelist<U, Tail> Result;
};

template <class T, class U>
struct Replace<NullType, T, U>
{
        typedef NullType Result;
};

using namespace std;

int main()
{
        typedef MakeTypelist<int, char, double>::Result typelist;
        int i = Length<typelist>::value;
        cout << "length of typelists is " << i << endl;

        TypeAt<typelist, 2>::Result d = 0.123;
        cout << "num = " << d << endl;

        i = IndexOf<typelist, int>::value;
        cout << "index of int in typelist is " << i << endl;

        typedef Append<typelist, float>::Result typelist2;
        i = IndexOf<typelist2, float>::value;
        cout << "index of float in typelist2 is " << i << endl;

        typedef Erase<typelist2, float>::Result typelist3;
        i = IndexOf<typelist3, float>::value;
        cout << "index of float in typelist3 is " << i << endl;

        typedef MakeTypelist<int, char, char>::Result typelist4;
        typedef EraseAll<typelist4, char>::Result typelist5;
        i = IndexOf<typelist5, char>::value;
        cout << "index of char in typelist5 is " << i << endl;

        typedef NoDuplicates<typelist4>::Result typelist6;
        i = IndexOf<typelist6, char>::value;
        cout << "index of char in typelist6 is " << i << endl;

        typedef Replace<typelist, double, unsigned char>::Result typelist7;
        i = IndexOf<typelist7, unsigned char>::value;
        cout << "index of unsigned char in typelist7 is " << i << endl;

        return 0;
}

converse

续上...

4)添加一个新类型到typelist中

/********************************************************************
        添加一个类型到typelist的后面
*********************************************************************/
template <class TList, class T>
struct Append;
// 在typelist中一直查找nulltype下去,找到的时候就把类型添加进去返回
template <class Head, class Tail, class T>
struct Append<Typelist<Head, Tail>, T>
{
        typedef Typelist<Head, typename Append<Tail, T>::Result> Result;
};

template <class Head, class Tail>
struct Append<NullType, Typelist<Head, Tail> >
{
        typedef Typelist<Head, Tail> Result;
};

// 针对nulltype的偏特化，此时已经查找到链表尾，生成一个只含有一个类型的typelist返回
template <class T>
struct Append<NullType, T>
{
        typedef TYPELIST_1(T) Result;
};

// 针对空链表的偏特化
template <>
struct Append<NullType, NullType>
{
        typedef NullType Result;
};

查找typelist一直到查找到nulltype也就是链表结束的地方，生成一个只含有新增加的类型的typelist返回。

converse

续上...

5)移除某个类型的第一次出现

/********************************************************************
        移除typelist中某个类型的第一次出现
*********************************************************************/
// 当head == T的时候,这个查找过程结束,返回Tail
// 否则将一直查找下去
template<class TList, class T>
struct Erase
{
        typedef Typelist<typename TList::Head, typename Erase<typename TList::Tail, T>::Result> Result;
};

// 当head == T时把tail返回
template <class T, class Tail>
struct Erase<Typelist<T, Tail>, T>
{
        typedef Tail Result;
};

template <class T>
struct Erase<NullType, T>
{
        typedef NullType Result;
};

当需要移除的类型为head时，把tail返回达到移除的效果。

converse

续上....

6)移除某个类型的所有出现

/********************************************************************
        移除typelist中某个类型的所有出现
*********************************************************************/
template<class TList, class T>
struct EraseAll
{
        typedef Typelist<typename TList::Head, typename EraseAll<typename TList::Tail, T>::Result> Result;
};

// 继续在tail中删除类型T
template <class T, class Tail>
struct EraseAll<Typelist<T, Tail>, T>
{
        typedef typename EraseAll<Tail, T>::Result Result;
};

template <class T>
struct EraseAll<NullType, T>
{
        typedef NullType Result;
};

基本思想和erase类似，不同的是删除了需要删除的类型时不是直接返回而是继续查找下去

okmmno1

难度太高，应者寥寥阿，楼主继续。

GoneWindy

很有难度！
看的头疼！
lz加油

飞灰橙

请教楼主，如何写一个通用的模板, 判断一个类是否是POD?
因为我想对一个搜索算法特化, 对于指向POD类型的random iterator,
可以有更快的搜索方法.

想了好久，无果。
我看过boost里的is_pod, 其实是几乎不能工作的.