C++博客-tommy-随笔分类-泛型编程与设计模式

递归数查寻表

Tommy Liang — Sat, 22 Apr 2006 04:48:00 GMT

最多到17，18就不对了

// knapSackSupportTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

typedef __int64 DT;

template<int N>
struct factorial{
    static const DT value = N * factorial<N-1>::value;
};

template<>
struct factorial<1>{
    static const DT value = 1;
};
static DT arrFactorial[32];

int _tmain(int argc, _TCHAR* argv[])
{
    arrFactorial[1] = factorial<1>().value;
    arrFactorial[2] = factorial<2>().value;
    arrFactorial[3] = factorial<3>().value;
    arrFactorial[4] = factorial<4>().value;
    arrFactorial[5] = factorial<5>().value;
    arrFactorial[6] = factorial<6>().value;
    arrFactorial[7] = factorial<7>().value;
    arrFactorial[8] = factorial<8>().value;
    arrFactorial[9] = factorial<9>().value;
    arrFactorial[10] = factorial<10>().value;
    arrFactorial[11] = factorial<11>().value;
    arrFactorial[12] = factorial<12>().value;
    arrFactorial[13] = factorial<13>().value;
    arrFactorial[14] = factorial<14>().value;
    arrFactorial[15] = factorial<15>().value;
    arrFactorial[16] = factorial<16>().value;
    arrFactorial[17] = factorial<17>().value;

    for(int i=1;i < 18;i++)
    {
        printf("factorial of %d=%u\n",i,arrFactorial[i]);
    }

    return 0;
}

Tommy Liang 2006-04-22 12:48 发表评论

读书笔记《C++设计新思维》(8) 边界标记：NullType和EmptyType

Tommy Liang — Sun, 05 Feb 2006 17:29:00 GMT

书里面说的这个词：
型别计算的边界标记

NullType只有声明没有定义。

class NullType;

这是为了表达“我不是个令人感兴趣的型别”，可以作为“找不到型别”的消息标记。类似\0这样。

EmptyType，就是一个空类

struct EmptyType {};

这是可被继承的合法型别，可以作为template的缺省参数型别。

Tommy Liang 2006-02-06 01:29 发表评论

读书笔记《C++设计新思维》(7) std::type_info类的包装类

Tommy Liang — Sun, 05 Feb 2006 17:20:00 GMT

std::type_info类可以在执行期间查询对象型别，但使用起来比较麻烦。为此定义了wrapper

下面的代码出自 Loki库：
总得来说是提供了std::type_info的所有成员函数；
提供了value语义，即public copy构造函数和public assignment操作符；
定义了 operator< 和 operator== 等

namespace Loki
{
////////////////////////////////////////////////////////////////////////////////
// class TypeInfo
// Purpose: offer a first-class, comparable wrapper over std::type_info
////////////////////////////////////////////////////////////////////////////////

    class TypeInfo
    {
    public:
        // Constructors
        TypeInfo(); // needed for containers
        TypeInfo(const std::type_info&); // non-explicit

        // Access for the wrapped std::type_info
        const std::type_info& Get() const;
        // Compatibility functions
        bool before(const TypeInfo& rhs) const;
        const char* name() const;

    private:
        const std::type_info* pInfo_;
    };

// Implementation

    inline TypeInfo::TypeInfo()
    {
        class Nil {};
        pInfo_ = &typeid(Nil);
        assert(pInfo_);
    }

    inline TypeInfo::TypeInfo(const std::type_info& ti)
    : pInfo_(&ti)
    { assert(pInfo_); }

    inline bool TypeInfo::before(const TypeInfo& rhs) const
    {
        assert(pInfo_);
        return pInfo_->before(*rhs.pInfo_) != 0;
    }

    inline const std::type_info& TypeInfo::Get() const
    {
        assert(pInfo_);
        return *pInfo_;
    }

    inline const char* TypeInfo::name() const
    {
        assert(pInfo_);
        return pInfo_->name();
    }

// Comparison operators

    inline bool operator==(const TypeInfo& lhs, const TypeInfo& rhs)
    { return (lhs.Get() == rhs.Get()) != 0; }

    inline bool operator<(const TypeInfo& lhs, const TypeInfo& rhs)
    { return lhs.before(rhs); }

    inline bool operator!=(const TypeInfo& lhs, const TypeInfo& rhs)
    { return !(lhs == rhs); }

    inline bool operator>(const TypeInfo& lhs, const TypeInfo& rhs)
    { return rhs < lhs; }

    inline bool operator<=(const TypeInfo& lhs, const TypeInfo& rhs)
    { return !(lhs > rhs); }

    inline bool operator>=(const TypeInfo& lhs, const TypeInfo& rhs)
    { return !(lhs < rhs); }
}

Tommy Liang 2006-02-06 01:20 发表评论

读书笔记《C++设计新思维》(6) 编译期间侦测继承性

Tommy Liang — Sun, 05 Feb 2006 17:11:00 GMT

在编译时刻，在Conversion类中产生两个常数（编译器帮忙计算）

template <class T,class U>
class Conversion
{
    //
public:
    enum { exists2Way = exists && Conversion<U,T>::exists };
        enum { sameType = false };
};

一个是 exists2Way，表示是否可以两个类型互相转换，
sameType 表示 T和U是否同一个类型。
不过，虽然书里这么说，我怎么都搞不懂为什么这样可以，测试也是不对的，难道这个sameType的写法还有别的奥妙？
不过下面这个偏特的写法倒是比较容易理解：

template <class T>
class Conversion<T,T>
{
public:
enum { exists = 1,exists2Way = 1,sameType = 1 };
};

这个测试是OK的。

有了这几个常数，要决定两个class之间是否存在继承关系就比较容易了：

#define SUPERSUBCLASS(T,U) \
(Conversion<const U*, const T*>::exists && \
!Conversion<const T*, const void*>::sameType)

如果U是public继承自T，或者T和U是同一个类，那么SUPERSUBCLASS(T,U)传回true，这里是把某个class视为自己的超类，更严谨的做法是：

#define SUPERSUBCLASS_STRICT(T,U) \
(SUPERSUBCLASS(T,U) && \
!Conversion<const T, const U>::sameType)

即排除T与U是同一个类型的情况。

另外，加上 const 是为了防止因为 const 而导致转型失败，对于已经是const的东西再const一次的话后面一次的const会忽略掉。

再，这个宏的名字很清晰，就是超类--子类，前面那个T是超类，U是子类，这个命名比 INHERITS要好。

Tommy Liang 2006-02-06 01:11 发表评论

读书笔记《C++设计新思维》(5) 编译期间侦测可转换性

Tommy Liang — Sat, 04 Feb 2006 21:34:00 GMT

就是这样一个类：

template <class T,class U>
class Conversion
{
    typedef char Small;
    class Big { char dummy[2]; };
    static Small Test(U);
    static Big Test();
    static T MakeT();
public:
    enum { exists = sizeof(Test(MakeT())) == sizeof(Small) };
};

关于函数 Small Test(U) 和 Big Test(...) ，书里面说：

。。。需要两个重载函数，其一如先前所说，接受一个U对象并传回一个Small对象：
Small Test(U);
但接下来，我该如何写出一个可接受任何其他种对象的函数呢？。。。。

我觉得这个地方翻译得有点问题，是不是应该说：“。。我该如何写出一个可接受任何另外一种类型（即 T）的对象的函数呢。。”，因为这里就是 T和U嘛，没有什么“其他种”，这样翻译容易让我迷惑不解了一会儿。

如果接受 U的那个函数被调用，则T可以被转换为 U，否则无法转换，这个是思路的根本。

为什么要做一个 MakeT这样的函数而不直接使用T呢？这是为了满足当 T 只有私有构造函数的情况，对于编译器来说，sizeof 是在编译期完成评估的，所以，MakeT 里面到底做了什么并不重要，重要的是他返回的类型，是 T，所以，作者很兴奋地说，这是一个 StrawMan function，即“稻草人函数”，哈哈，只是一个样子而已，但是这已经足够了，那两个重载的Test方法也是一样，这里我们不关心他的函数体。强啊，爽歪歪，快感的源泉啊

测试代码如下：

    using namespace std;

    cout << Conversion<double, int>::exists << ' '
        << Conversion<char, char*>::exists << ' '
        << Conversion<size_t, vector<int> >::exists << ' ';

输出： 1 0 0
double可以转换为 int
char 不能转换为 char*
vector 是一个容器的构造函数，size_t 不能转换，因为这个构造函数是 explicit的,这个地方还是有点迷糊，还得研究一下。

Tommy Liang 2006-02-05 05:34 发表评论

读书笔记《C++设计新思维》(4) Type Selection

Tommy Liang — Sat, 04 Feb 2006 20:53:00 GMT

睡不着，继续读书

有时候，范型程序需要根据一个boolean变量来选择某个型别或另一个型别。
下面定义的结构提出了解决方案：

template <bool flag,typename T,typename U>
struct Select
{
typedef T Result;
};
//偏特化
template <typename T,typename U>
struct Select<false,T,U>
{
typedef U Result;
};

也就是说，如果flag是true，则编译器使用第一份定义，即Result被定义为T，
如果是false,则偏特化机制起作用，Result被定义为 U

偏特化真强，全在乎想象力了

Tommy Liang 2006-02-05 04:53 发表评论

读书笔记《C++设计新思维》(3) Type2Type的意义

Tommy Liang — Sat, 04 Feb 2006 20:40:00 GMT

就是这样一个结构：

template <typename T>
struct Type2Type
{
typedef T OriginalType;
};

假定有个片断如下，创建一个T*

template <class T,class U>
T* Create(const U& arg)
{
return new T(arg);
}

如果对于某个类如“Widget”，其ctor要有两个参数，比如第二个参数必须是-1（对于旧的代码来说，谁知道呢:)），但又不想另外创建一个“CreateWidget”方法，那么怎么办呢，函数是不能偏特化的，即如下代码：

//错误的代码
template <class U>
Widget* Create<Widget,U>(const U& arg)
{
return new Widget(arg,-1);
}

在 VC7下会报告：非法使用显式模板参数

只能使用函数重载，比如：

template <class T,class U>
T* Create(const U&arg,T /*虚拟*/)
{
return new T(arg);
}

template <class U>
Widget * Create(const U& arg, Widget /*虚拟*/)
{
return new Widget(arg,-1);
}

这样是可以解决问题，但最大的毛病在于运行时构造了未被使用的对象这个开销（虚拟的Widget参数）。这时 Type2Type 这个咚咚出场了，按照书的说法，这是“一个型别代表物、一个可以让你传给重载函数的轻量级ID”，如下：

template <class T,class U>
T* Create(const U& arg,Type2Type<T>)
{
return new T(arg);
}

template <class U>
Widget * Create(const U& arg,Type2Type<Widget>)
{
return new Widget(arg,-1);
}

调用方：
String *pStr = Create("hello",Type2Type<String>());
Widget *pW = Create(100,Type2Type<Widget>());

关键是，这个东西也是给编译器看的，妙

Tommy Liang 2006-02-05 04:40 发表评论

读书笔记《C++设计新思维》(2) Int2Type的意义

Tommy Liang — Mon, 23 Jan 2006 18:20:00 GMT

就是这么一个模板结构，所有的价值在于编译时刻根据常数调用不同函数或者编译期实施编译分支的分派。

template <int v>
struct Int2Type
{
enum { value = v };
};

如下：

template <typename T, bool isPolimorphic>
class NiftyContainer
{
private:
    void DoSomething( T* pObj, Int2Type<true>)
    {
        T* pNewObj = pObj->Clone();
    }
    void DoSomething( T* pObj, Int2Type<false>)
    {
        T * pNewObj = new T(*pObj);
    }
public:
    void DoSomething(T * pObj)
    {
        DoSomething(pObj, Int2Type<isPolimorphic>());
    }
};

如果没有这个 Int2Type，是不可能实现两个“重载”函数 DoSomething( .. Int2Type)和 DoSomething(...Int2Type)的，NiftyContainer的参数 isPolimorphic只能取true或者false，实际上编译出来的要么是前一个函数，要么是后一个函数。
如果没有这个Int2Type，最容易想到的就是像下面这样做：

if (isPolimorphic)
{
T * pNewObj = pSomeObj->Clone();
}
else
{
T * pNewObj = new T (*pSomeObj);
}

如果多态算法使用 pObj->Clone(),那么对于任何一个未曾定义 Clone函数（即isPolimorphic==false）的类来说，这里的前一个分支是编译失败的。反之，如果 isPolimorphic == true，是不是后面那个分支就保证没问题，一定能通过呢？不是的，如果有一个类设计成为有 Clone函数，但是构造函数是私有的，就不行咯。

所以， Int2Type是跟编译器说：嘿，不要去管那个我不关心的分支。

妙啊！

Tommy Liang 2006-01-24 02:20 发表评论

读书笔记《C++设计新思维》(1) Template Template 参数

Tommy Liang — Fri, 20 Jan 2006 20:39:00 GMT

下面的代码，所谓 "Template Template 参数"，在 VC6 下面编译是会报告“template can't be nested”的，幸好， VC7是能成功编译的，否则这本《C++设计新思维》就很难看下去了，

template <class T>
struct OpNewCreator
{
    static T* Create()
    {
        return new T;
    }
};
template <class T>
struct MallocCreator
{
    static T* Create()
    {
        void * buf = std::malloc(sizeof(T));
        if (! buf ) return 0;
        return new(buf) T;
    }
};
template <class T>
struct PrototypeCreator
{
    PrototypeCreator(T* pObj = 0) : pPrototype_(pObj)
    {}
    T * Create()
    {
        return pPrototype_ ? pPrototype_->Clone() : 0;
    }
    T* GetPrototype() { return pPrototype_; }
    void SetPrototype(T * pObj) { pPrototype_ = pObj; }
private:
    T* pPrototype_;
};

class Widget
{
};

template <template <class Created> class CreationPolicy>
class WidgetManager : public CreationPolicy<Widget>
{
    //
};

int _tmain(int argc, _TCHAR* argv[])
{
    typedef WidgetManager< OpNewCreator >  myWidgetMgr;

    return 0;
}

Tommy Liang 2006-01-21 04:39 发表评论