C++博客-(define (cuigang) (coding))-文章分类-《C++设计新思维》读书笔记

《C++设计新思维》读书笔记（23）

cuigang — Sat, 12 Jan 2008 12:29:00 GMT

4.4
Chunks（大块内存）
每个Chunk对象包含并管理一大块内存，其中包含固定数量的区块。你可以在构造期间设定区块的大小和数量。你可以从chunk中分配和归还区块。一旦chunk之中没有剩余区块，分配函数便传回0。chunk定义如下：

// Nothing is private - Chunk is a Plain Old Data (POD) structure
// structure defined inside FixedAllocator
// and manipulated only by it
struct Chunk{
    void Init(std::size_t blockSize, unsigned char blocks);
    void Release();
    void* Allocate(std::size_t blockSize);
    void Deallocate(void* p, std::size_t blockSize);
    unsigned char* pData_;
    unsigned char
        firstAvailableBlock_,
        blocksAvailable_;
};



除了一个指针指向被管理内存本身，firstAvailableBlock_保存chunk内第一个可用区块的索引，blocksAvailable_保存chunk内可用区块总数。
Chunk的接口非常简单。Init()用于初始化，Release()用来释放。Allocate()用来分配，Deallocate()用来归还。Chunk不保存区块的大小，它没有构造函数、析构函数和赋值运算符，定义自己的copy语义会损及上一层的效率——上一层将chunk置于一个vector。
chunk的结构反应出设计中一个重要折衷。blocksAvailable_和firstAvailableBlock_都是unsigned char型别，因此一个chunk无法拥有255个以上的区块。
另外我们利用“未被使用的区块”的第一个bytes来存放下一个“未被使用的区块”的索引号。这样我们就拥有了一个单向链表。无需占用内存。
初始化函数如下：

void Chunk::Init(std::size_t blockSize, unsigned char blocks){
    pData_ = new unsigned char[blockSize * blocks];
    firstAvailableBlock_ = 0;
    blocksAvailable_     = blcoks;
    unsigned char i      = 0;
    unsigned char* p     = pData_;
    for(; i != blocks; p += blockSize){
        *p = ++i;
    }
}



我们来看一下将区块数量限制在unsigned char的大小（0~255）的原因。假如我们使用一个较大型别，比如unsigned short（0~65535），我们将遭遇两个问题，一个小问题，一个大问题。
小问题是我们无法分配小于sizeof(unsigned
short)的区块，这令人尴尬，因为我们正在建立一个小型对象分配器。（这里指的是，对于1 byte区块大小的chunk，由于索引号有2 bytes，无法建立内嵌的单向链表，cuigang）。
大问题是齐位（alignment）问题。假设你为一个5 bytes区块建立一个专属分配器。这种情况下如果想将“指向如此一个5 bytes区块”的指针转换为unsigned int（原文如此，估计作者是想说从一个起始为奇地址的区块提领（dereference）一个偶字节变量会导致异常的问题，这几个函数中都有提领的动作。cuigang），会造成不确定行为。
unsigned
char类型可以简单的解决这个问题。它大小为1，无齐位问题。只不过我们将无法分配多于255的区块。但这个我们是可以接受的。
分配函数Allocate()是典型的list操作。

void* Chunk::Allocate(std::size_t blockSize){
    if(!blocksAvailable_) return 0;
    unsigned char* pResult =
        pData_ + (firstAvailableBlock_ * blockSize);
    firstAvailableBlock_ = *pResult;
    --blocksAvailable_;
    return pResult;
};



这个函数成本很小，不需要查找动作，在常数事件内完成，而不像系统分配需要线性时间。
归还函数Deallocate()行为相反，这里要注意，由于Chunk对区块大小一无所知，所以你必须将区块大小当作参数传入，同时注意里面很多的异常处理来避免你将错误指针传入：

void Chunk::Deallocate(void* p, std::size_t blockSize){
    assert(p >= pData_);
    unsigned char* toRelease = static_cast<unsigned char*>(p);
    assert((toRelease - pData_) % blockSize == 0);
    *toRelease = firstAvailableBlock_;
    firstAvailableBlcok_ = static_cast<unsigned char>(
        (toRelease - pData_) / blockSize);
    assert(firstAvailableBlock == (toRelease - pData_) / blockSize);
    ++blocksAvailable_;
};

cuigang 2008-01-12 20:29 发表评论

《C++设计新思维》读书笔记（22）

cuigang — Thu, 10 Jan 2008 15:00:00 GMT

4.2 内存分配器的工作方式

（本节内容可以参考操作系统书籍，cuigang）

内存分配器如何工作？它管理一个由raw bytes所组成的内存池。薄记结构可以简单如下：

struct MemControlBlock{
std::size_t size_;
bool available_;
};

MemControlBlock对象管理的内存紧随其后，大小 size_，然后是另一个控制块。初始时，内存池中只有一个MemControlBlock，并将所有内存视为一大块，这就是所谓root控制块，永不离开最初位置。以

+===================+=================+==================+
| available_ : ture | size_ : 1048571 | mem[1048571] |
+===================+=================+==================+
| |
|-----> 1 byte <----|----> 4 bytes <--|-> 1048571bytes <-|
|-----------------------> 1048576 bytes <----------------|

每次分配都引发一次线性查找，找到一个合适区块，适合策略有最先匹配法则（first fit）、最佳匹配（best fit），最差匹配（worst fit），甚至随机匹配（random fit）。有趣的是最差匹配比最佳匹配好！

每次归还区块，同样需要一次线性搜索，找出待归还区块的前一区块并调整大小。

如你所看，这一策略时间上并非高效。但空间上开销较小，甚至我们可以再调整：

//注意下面代码依赖编译器和平台
struct MemControlBlock{
std::size_t size_ : 31;
bool available_ : 1;
};

为了前序遍历，我们可以定义为双向链表：

struct MemControlBlock{
    bool available_;
    MemControlBlock* next_;
    MemControlBlock* prev_;
};

这里我们不需要size_了，我们可以通过this->next - this 来得到。

尽管如此，分配动作还是得消耗线性时间。要减轻这样的消耗，有如多巧妙技术可用，但都各有利弊，存在某种情况下的不良性能（参考Knuth著作）。这里我们不对其讨论，我们的焦点是可最佳处理小型对象的“专用分配器”。

4.3 小型对象分配器

本章介绍的小型对象分配器分为4层结构。如图所示，下层提供功能供上层使用。

+-------------------+
|    SmallObject    |
+-------------------+
| SmallObjAllocator |
+-------------------+
|   FixedAllocator |
+-------------------+
|       Chunk       |
+-------------------+

最下层是Chunk对象，每一个Chunk管理一大块内存，此大块内存包含整数个固定大小的区块。可以用来分配和归还，当其中没有剩余时，分配失败返回零。

第二层是FixAllocator class，其以Chunk为构件。主要用来满足那些“累计总量超过Chunk容量”的请求。FixAllocator通过一个array（实际是vector）组合Chunks。如果所有Chunk都被使用，FixAllocator分配新Chunk，并加入array，来满足需求。

第三层是SmallObjectAllocator提供通用分配/归还函数。拥有数个FixedAllocator对象，每个负责分配某特定大小对象。根据申请bytes个数不同，SmallObjAllocator对象会将内存分配申请分发。如果请求量过大，会转交系统new。

第四层是SmallObject，它包装FixedAllocator，以便向C++ classes提供封装良好的分配服务。SmallObject重载new和delete。你只需要让你的对象派生于SmallObject。

cuigang 2008-01-10 23:00 发表评论

《C++设计新思维》读书笔记（21）

cuigang — Thu, 10 Jan 2008 14:54:00 GMT

3.13 运用typelist自动产生classes（不好意思，没太看懂，略去）

4 小型对象分配技术

4.1 缺省的Free Store分配器

由于某些“神秘原因”，系统缺省的free store分配器速度极慢，恶名昭彰。其中一个可能的原因是，它通常只是C heap分配器（malloc/realloc/free）的浅层包装。C heap分配器并未特别针对小块内存的分配进行优化。C程序通常十分有条理地、保守地使用内存，却不会采用任何“导致小块内存被大量分配”的手法或技巧。C程序通常分配中大型对象（数百或者数千个bytes）。

除了速度慢，C++缺省分配器的通用性也造成小型对象空间分配的低效。（细述，指对小对象会额外分配空间，以保证不小于最小区块，而且链表的薄记管理部分也开销很大，对小对象比较多时尤为明显）。

在C++中，动态分配很重要。执行期多态性和动态分配的联系最为密切。“Pimpl手法”就要求“以free store分配取代stack分配”为前提。

因此，在迈向高效C++程序开发的道路上，缺省分配器的低劣性能成为一种障碍。老练的C++程序员会尽量避免使用“采行free store分配行为”的语言构件，因为根据经验他们知道它的成本高昂。缺省分配器不仅是个具体问题，还可能成为一个心理障碍。

cuigang 2008-01-10 22:54 发表评论

《C++设计新思维》读书笔记（20）

cuigang — Thu, 10 Jan 2008 14:49:00 GMT

3.9 移除typelist中的某个元素

移除第一个匹配者：

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

注意Erase这样使用会导致编译错误。移除所有匹配者的实现如下：

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

3.10 移除重复元素（略）
3.11 取代Typelist中的某个元素（略）
3.12 为Typelists局部更换次序（略）

cuigang 2008-01-10 22:49 发表评论

《C++设计新思维》读书笔记（19）

cuigang — Sat, 05 Jan 2008 04:19:00 GMT

3.6 索引式访问

索引式访问使typelist访问线性化。象在static世界中一样，索引必须是编译期常数。一个带有索引的template声明如下：

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;
};

如果你试着越界访问，会编译出错。对Typelist进行索引访问，花费的时间和typelist大小有关，但这个时间全部花在编译期。

3.7 查找Typelist

我们用IndexOf来查找Typelist中一个型别，返回其位置，找不到返回-1。

template <class TList, class T> struct IndexOf;
template <class T>
struct IndexOf<NullType, T>{
    enum{value = -1};
};
template <class Tail, class T>
struct IndexOf<Typelist<T, Tail>, T>{
    enum{value = 0;}
};
template <class Head, class Tail, class T>
struct IndexOf<Typelist<Head, Tail>, T>{
private:
    enum{temp = IndexOf<Tail, T>::vale};
public:
    enum{value = temp == -1 ? -1 : 1+temp};
};

最后一个特化版本用了问号表达式来实现分支判断。

3.8 追加元素至Typelist

修改typelist是不可能的，我们以by value方式传回一个新typelist。

template <class TList, class T> struct Append;
template <> struct Append<NullType, NullType>{
    typedef NullType Result;
};
template <class T> struct Append<NullType, T>{
    typedef TYPELIST_1(T) Result;
};
template <class Head, class Tail>
struct Append<NullType, Typelist<Head, Tail> >{
    typedef Typelist<Head, Tail> Result;
};
template <class Head, class Tail, class T>
struct Append<Typelist<Head, Tail>, T>{
    typedef Typelist<Head, typename Append<Tail,T>::Result> Result;
};

这个实现比较复杂，特别是最后一个偏特化版本，它递归具现Append，每次递归都将tail和待追加型别传递进去。

cuigang 2008-01-05 12:19 发表评论

《C++设计新思维》读书笔记（18）

cuigang — Sat, 05 Jan 2008 04:15:00 GMT

3.4 计算长度

我们用下面代码来计算typelist长度：

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 };
};

由Length::value得到的值是一个编译期常数，我们可以用它来定义数组大小，

std::type_info* intsRtti[Length<SignedIntegrals>::value];

这个模板代码依靠递归来完成，第一个版本是一个全特化，第二个版本是一个偏特化。

3.5 间奏曲

这里有一个问题，在上节的Length实现中，我们能否用迭代来取代递归？答案是否定的。因为我们在编译期编程中，可以使用的仅是：template、编译期整数计算、typedef。

1、templates：更明确的说是模板特化，提供编译期的if叙述。
2、整数计算：提供数值计算能力，用以从型别转为数值。但数值是不可改变的。
3、typedef：可视为用来引进“具名的型别常数”。它们也是定义之后就冻结，你不能将typedef定义的符号重新定义为另一个型别。

这些特性决定了我们无法使用迭代。所谓迭代是持有一个迭代器，并改变它，直到某些条件吻合。由于编译期我们没有“可资变化的任何东西”，所以无法实现“迭代”。所以编译期运算只能象那些纯粹函数型语言，使用大量的递归。

cuigang 2008-01-05 12:15 发表评论

《C++设计新思维》读书笔记（17）

cuigang — Sat, 29 Dec 2007 14:08:00 GMT

3.2 定义Typelists

1
2 template <class T, class U>
3 struct Typelist
4 {
5 typedef T head;
6 typedef U Tail;
7 };

Typelists内部没有任何数值：它的实体是空的。它们存在的理由只是为了携带型别信息。因此，对typelist的任何处理都发生在编译期。此后我们提到一个typelist，指的是一个型别而非一个对象。虽然typlist只有两个参数，但我们可以把任意一个替换为另一个typelist，来达到无限延伸的目的。

另外我们需要一个零个型别以及一个型别的typelist。对于零个型别，前面提到的NullType就可以，对于一个型别，我们可以这样定义：

1 typedef Typelist<int, NullType> OneTypeOnly;

3.3 将Typelist生成线性化

像这样一个typelist

1
2 typedef Typlist<int, Typelist<int, Typelist<int, Typelist<int, int> > > > Int4Type;

它太Lisp了，我们定义一系列的宏来完成它，这样我们可以忘记尖括号间的空格。

1 #define TYPELIST_1(T1) Typelist
2 #define TYPELIST_2(T1, T2) Typelist
3 #define TYPELIST_3(T1, T2, T3) Typelist
4 #define TYPELIST_4(T1, T2, T3, T4) Typelist
5 //etc
6 #define TYPELIST_50(/* */) //

这样前面的 Int4Type 就可以这样定义

1 typedef Int4Type TYPELIST_4(int, int, int, int) Int4Type;

这只是包装手法的一个开端。我们访问Int4Type的最后一个元素还比较麻烦，需要

1 Int4Type::Tail::Tail::Tail;

我们还要进一步来考虑它操作的问题。

cuigang 2007-12-29 22:08 发表评论

《C++设计新思维》读书笔记（16）

cuigang — Sat, 29 Dec 2007 14:05:00 GMT

3. Typelists

Typelists是一个用来操作一大群型别的C++工具。就像lists对数值提供各种基本操作一样，typelists对型别也提供相同操作。

有些设计模式具体指定并操作一群型别，其中也许有继承关系（但也许没有）。显著的例子是abstract factory和visitor。如果以传统编程技术来操作一大群型别，将是全然的重复工作。如此重复会导致隐微的代码膨胀。多数人不会想到其实它可以比现在更好。Typelists带给你一种能力，可以将经常性的宏工作自动化。Typelists将来自外星球的强大威力带到C++中，让它得以支持新而有趣的一些手法。

3.1 Typelists的必要性

有时候你必须针对某些型别重复撰写相同代码，而templates无法帮上忙。假如有一个abstract factory，像这样：

1 class WidgetFactory
2 {
3 public:
4     virtual Window* CreateWindow() = 0;
5     virtual Button* CreateButton() = 0;
6     virtual ScrollBar* CreateScrollBar() = 0;
7 };

如果你想将Abstract Factory概念泛化，不只生成Window、Button、ScrollBar，而是任意型别。怎么办？

如果你不试图泛化基本概念，就不太有机会泛化这些概念的具象实体。虽然抽象基类很简单，但是你会陷入无穷无尽的派生类生成器中。

我们希望能够这样去使用一个abstract factory：

1
2 template <class T>
3 T* MakeRedWidget(WidgetFactory& factory)
4 {
5     T* pW = factory.Create<T>();
6     pW -> SetColor(RED);
7     return pW;
8 }

实际这是不可能的，如果Create不是虚函数，那么你就陷入了长长的Switch...case...之中，如果它是虚函数，那么虚函数不能是模板。
Typelists将使Abstract Factories泛化成真，并带来更多其它利益。

cuigang 2007-12-29 22:05 发表评论

《C++设计新思维》读书笔记（15）

cuigang — Tue, 25 Dec 2007 13:43:00 GMT

2.10.2 侦测基本型别（略）'
2.10.3 优化的参数型别（略）
2.10.4 卸除饰词

下面是一个“const 卸除器”：

1 template<typename T>
2 class TypeTraits
3 {
4 private:
5     template<class U> struct UnConst
6     {
7         typedef U Result;
8     };
9     template<class U> struct UnConst<const U>
10     {
11         typedef U Result;
12     };
13 public:
14     typedef UnConst<T>::Result NonConstType;
15 };

2.10.5 运用TypeTraits

这里实作一个调用BitBlast的例子：

1 enum CopyAlgoSelector{Conservative, Fast};
2
3 // Conservative routine-works for any type
4 template
5 OutIt CopyImpl(InIt first, InIt last, OutIt result, Int2Type)
6 {
7     for(; first != last; ++first, ++result)
8         *result = *first;
9 }
10
11 // Fast routine-works only for pointers to raw data
12 template
13 OutIt CopyImpl(InIt first, InIt last, OutIt result, Int2Type)
14 {
15     const size_t n = last - first;
16     BitBlast(first, result, n * sizeof(*first));
17     return result + n;
18 }
19
20 template struct SupportsBitwiseCopy
21 {
22     enum{result = TypeTraits::isStdFundamental};
23 }
24
25 template
26 OutIt Copy(InIt first, InIt last, OutIt result)
27 {
28     typedef TypeTraits::PointeeType SrcPointee;
29     typedef TypeTraits::PointeeType DestPointee;
30     enum { copyAlgo =
31         TypeTraits::IsPointer &&
32         TypeTraits::IsPointer &&
33         SupportsBitwiseCopy::result &&
34         SupportsBitwiseCopy::result &&
35         sizeof(SrcPointee) == sizeof(DestPointee) };
36     return CopyImpl(first, last, Int2Type);
37 }

对于一个POD结构（plain old data），即C struct，只有数据没有其它任何东西。因为无法甄别其类型，会调用慢速版本。我们可以这样做，让它调用快速版本，假如POD结构为Mytype。

1 template<> struct SupportsBitwiseCopy<MyTyee>
2 {
3 enum {result = true};
4 };

cuigang 2007-12-25 21:43 发表评论

《C++设计新思维》读书笔记（14）

cuigang — Mon, 24 Dec 2007 13:55:00 GMT

2.10.1 实作出Pointer Traits

大部分type traits的实作都依赖全特化或偏特化。下面代码用来判断型别T是否为指针：

1 template<typename T>
2 class TypeTraits
3 {
4 private:
5     template<class U> struct PointerTraits
6     {
7         enum { result = false };
8         typedef NullType PointeeType;
9     };
10     template<class U> struct PointerTraits<U*>
11     {
12         enum { result = true };
13         typedef U PointeeType;
14     };
15 public:
16     enum { isPointer = PointerTraits<T>::result };
17     typedef PointerTraits<T>::Pointeetype PointeeType;
18 };

对于一个指针型别，PointerTraits的偏特化版本更适合。所以对于一个非指针型别，result为false，所谓被指型别PointeeType不能拿来使用，只是一个不能被使用的占位型别（placeholder type）。

对于指向成员函数的指针，我们需要这样做：

1 template<typename T>
2 class TypeTraits
3 {
4 private:
5     template <class U> struct PToMTraits
6     {
7         enum{result = false};
8     };
9     template <class U, class V>
10     struct PToMTraits<U, V::*>
11     {
12         enum {reulst = true };
13     }
14 public:
15     enum { isMemberPointer = PToMTraits<T>::result};
16 };
17

cuigang 2007-12-24 21:55 发表评论

《C++设计新思维》读书笔记（13）

cuigang — Sun, 23 Dec 2007 04:14:00 GMT

2.8 type_info的一个外覆类（Wrapper）

因为std::type_info类不太好用，作者提供的Loki库对其包装了一下，这节对其进行介绍，省去。

2.9 NullType 和 EmptyType

Loki定义了两个非常简单的型别：NullType 和 EmptyType。可以作为型别计算的边界。

1 class NullType; //没有定义
2 class EmptyType{};

第3章会展示其用途。

2.10 Type Traits

Traits 是一种“可于编译期根据型别作判断”的泛型技术，很想你在执行期根据数值进行判断一样。假设你想实作 Copying算法：

1 template <typename InIt, typename OutIt>
2 OutIt Copy(InIt first, InIt last, OutIt result)
3 {
4 for(; fist!=last; ++first, ++result)
5 *result = *first;
6 }

另外假设你有一个针对硬件优化的非常快的内建函数，你希望尽可能发挥改函数的好处。

1 void BitBlast(const void* src, void* dest, size_t bytes);

这是一个只针对基本型别并有着简朴旧式结构的实作，你不能将它用于拥有“nontrivial copy构造函数”的型别上。你可能需要对型别判断，以判断是否可以利用BitBlast，以便对基本型别快速执行。

你需要判断：
1、InIt 和 OutIt是一般指针吗？（针对iterator迭代器而言）
2、InIt 和 OutIt所指的型别可以bitwise copy（位逐一拷贝）吗？

Type traits 有助于解决这样的问题。

cuigang 2007-12-23 12:14 发表评论

《C++设计新思维》读书笔记（12）

cuigang — Sun, 23 Dec 2007 04:12:00 GMT

2.7 编译期间侦测可转换性和继承性

在泛型编程中，经常遭遇一个问题：对于两个型别T和U，如何得知U是否继承于T。我们需要在编译时发现这样的关系，而不必使用dynamic_cast——它会损耗执行期效率。

我们利用sizeof 和重载函数。比如如下定义两个类型，和两个函数，一个函数接收U类型，一个接收任意类型。

1 typedef char Small;
2 class Big {char dummy[2];};
3 Small Test(U);
4 Big Test();//省略号参数函数

我们传一个T类型对象给Test函数，看它能不能转换为U：

1 const bool convExists = sizeof(Test(T())) == sizeof(Small);

但如果T的缺省构造函数为私有，则会编译失败，所以我们用一个“稻草人函数”：

1 T MakeT();
2 const bool convExists = sizeof(Test(MakeT())) == sizeof(Small);

我们注意，sizeof()里面的东西不需要具现，所以T对象，MakeT()、Test()都不需要实作。它们根本不真正存在！！现在用class template包装起来。

1 template<class T, class U>
2 class Conversion
3 {
4     typedef char Small;
5     class Big {char dummy[2];};
6     static Small Test(U);
7     static Big Test();
8     static T MakeT();
9 public:
10     // T可以转换为U
11     enum {exists = sizeof(Test(MakeT())) == sizeof(Small)};
12     // 可以双向转换
13     enum {exists2Way = exists && conversion<U, T>::exists };
14     enum {sameType = false};
15 };
16 //利用偏特化处理 sameType == true 情况
17 template<class T>
18 class Conversion<T, T>
19 {
20 public:
21     enum { exists = 1, exists2Way = 1, sameType = 1};
22 };

最后，我们可以根据这个来判断两个类之间是否有继承关系：

1 #define SUPER_SUB_CLASS(T, U)\
2 (Conversion<const U*, const T*>::exists &&\
3 !Conversion<const T*, const void*>::sameType)

如果U是共有继承于T，或者T和U是同一型别，SUPER_SUB_CLASS(T, U)都传回true。这里加上const饰词的原因是，我们不希望因const而导致转换失败，对一个型别const两次，第二个const会被忽略。

cuigang 2007-12-23 12:12 发表评论

《C++设计新思维》读书笔记（11）

cuigang — Thu, 20 Dec 2007 14:00:00 GMT

2.6 型别选择

有时候，泛型程序需要根据一个bool量来选择某个型别。

假如对NiftyContainer，你需要一个std::vector作为后端存储结构。那么可能对于多态型别，你不能存储实体，只能存储指针。而对于非多态型别，你可以存储实体，因为这样有效率。

在你的class template中：

1 template <typename T, bool isPolymorphic>
2 class NiftyContainer
3 {
4 //
5 };

你要放一个 vector 或者 vector。根据isPolymorphic来定，你可以使用 traits class template 如下：

1 template <typename T, bool isPolymorphoic>
2 struct NiftyContainerValueTraits
3 {
4     typedef T* ValueType;
5 };
6 template <typename T>
7 struct NiftyContainerValueTraits<T, false>
8 {
9     typedef T ValueType;
10 };
11 template <typename T, bool isPolymorphic>
12 class NiftyContainer
13 {
14     //
15     typedef NiftyContainerValueTraits<T, isPolymoriphic> Traits;
16     typedef typename Traits::ValueType ValueType;
17     vector<ValueType> vec;
18 };

这种方法难用而且没有复用性，我们可以这样做：

1 template <bool flag, typename T, typename U>
2 struct Select
3 {
4     typedef T Result;
5 };
6 template <typename T, typename U>
7 struct Select<false, T, U>
8 {
9     typedef U Result;
10 };
11 template <typename T, bool isPolymorphic>
12 class NiftyContainer
13 {
14     //
15     typedef Select<isPolymorphic, T*, T>::Result ValueType;
16     vector<ValueType> vec;
17 };

cuigang 2007-12-20 22:00 发表评论

《C++设计新思维》读书笔记（十）

cuigang — Mon, 17 Dec 2007 14:16:00 GMT

2.5 型别对型别的映射（Type-to-Type Mapping）

如前所述，不可以对template函数偏特化。如有下面模板函数：

1 template<class T, class U>
2 T* Create(const U& arg)
3 {
4 return new T(arg);
5 }

用来构造一个对象。假设现在有一个widget对象的构造函数需要两个参数，第二个固定为-1。那么你没有办法如下偏特化，如果你写一个CreateWidget()来解决，你将不能在泛型程序中使用。

1 //示意代码，请勿模仿
2 template <class U>
3 widget* Create<widget, U>(const U& arg)
4 {
5 return new widget(arg, -1);
6 }

我们可以通过重载机制来实现，比如传入一个型别为T的形参：

1 template < class T, class U>
2 T* Create(cosnt U& arg, T /* dummy */)
3 {
4 return new T(arg);
5 }
6 template <class U>
7 widget* Create(const U& arg, widget /* dummy */)
8 {
9 return new widget(arg, -1);
10 }

但是由于形参的传入，我们构造了一个临时对象，造成额外开销。我们需要一个轻量级的ID。就是Type2Type：

1 template <typename T>
2 struct Type2Type
3 {
4 typedef T OriginalType;
5 };
6

它没有任何数值，但它们各自不同型别。那么，现在可以这样写：

1 //依靠重载和Type2Type
2 template <class T, class U>
3 T* Create(const U& arg, Type2Type<T>)
4 {
5 return new T(arg);
6 }
7 template <class U>
8 widget* Create(const U& arg, Type2Type<widget>)
9 {
10 return new widget(arg, -1);
11 }
12 //cleint's code
13 String* pStr = Create("hello", Type2Type<string>());
14 widget* pW = Create(100, Type2Type<widget>());

第二个参数只是用来选择适合的重载函数。

cuigang 2007-12-17 22:16 发表评论

《C++设计新思维》读书笔记（九）

cuigang — Mon, 17 Dec 2007 14:15:00 GMT

2.4 常整数映射为型别

以下模板：

1 template < int v >
2 struct Int2Type{
3 enum { value = v };
4 }

Int2Type会根据引数所得的不同数值来产生不同型别。Int2Type<0> 和 Int2Type<1>是两种不同的类型。采用Int2Type可根据编译期计算出来的结果选用不同的函数。实际上你可以运用一个常数达到静态分派功能。

一般而言，符合下列两个条件可使用Int2Type：

a.有必要根据某个编译期常数调用一个或数个不同的函数。
b.有必要在编译期实施“分派”。

运行时分派可以使用if...else...或switch。但有时难以做到。举例如下：

假设一个容器NiftyContainer，

1 template <class T> class NiftyContainer{};

其内含指针，指向 T 的对象。为了复制容器中某个对象，你想调用copy构造函数（非多态）或虚函数Clone()（多态）。但你无法这样做：

1 template < typename T, bool isPolymorphic>
2 class NiftyContainer{
3     void DoSomething(){
4         T* pSomeObj = ;
5         if (isPolymorphic){
6             T* pNewObj = pSomeObje->Clone();
7             //
8         }else{
9             T* pNewObj = new T(*pSomeObj);
10             //
11         }
12 };

你会发现编译不过，编译器会发现未定义的函数。而Int2Type提供了一个办法：

1 template <typename T, bool isPolymrphoic>
2 class NiftyContainer{
3 private:
4     void DoSomething(T* pObj, Int2Type<true>){
5         T* pNewObj = pSomeObje->Clone();
6         //
7     }
8     void DoSomething(T* pObj, Int2Type<false>){
9         T* pNewObj = new T(*pSomeObj);
10         //
11     }
12 public:
13     void DoSomething(T* pObj){
14         DoSomething(pObj, Int2Type<isPolymorphoic>());
15     }
16 };

主要原因是编译器不会去编译一个未被用到的template函数。

cuigang 2007-12-17 22:15 发表评论

《C++设计新思维》读书笔记（八）

cuigang — Mon, 17 Dec 2007 14:13:00 GMT

2.3 局部类

你可以在函数中定义class：

1 void Fun(){
2 class Local{};
3 }

不过有些限制，local class不能定义静态成员变量，也不能访问非静态局部变量。但它可以用于模板函数：

1 class Interface{
2 public:
3     virtual void Fun()=0;
4 };
5
6 template <class T, class P>
7 Interface* MakeAdapter(const T& obj, const P& arg)
8 {
9     class Local : public Interface{
10     public:
11         Local(const T& obj, const P& arg)
12             : obj_(obj), arg_(arg){};
13         virtual void Fun(){
14             obj_.Call(arg_);
15         }
16     private:
17         T obj_;
18         P arg_;
19     };
20     return new Local(obj, arg);
21 };

事实证明，任何local classes的方法都可以用“函数外的模板类”来完成，也就是说，并非得局部类不可。不过，局部类可以提高符号的地域性，如上例，Local不能在函数外被继承，类似Java的final。

11章将应用产生所谓“弹簧垫”函数（trampoline functions）。

cuigang 2007-12-17 22:13 发表评论

《C++设计新思维》读书笔记（七）

cuigang — Mon, 17 Dec 2007 14:12:00 GMT

2.2 模板偏特化

模板偏特化让你在template的所有可能实体中特化出一组子集。如：

1
2 template < class Window, class Controller>
3 class Widget{};

你可以这样加以特化：

1 template <>
2 class Widget<ModalDialog, MyController>
3 {};

其中，ModalDialog 和 MyController 是另外定义的类。
有时候，你需要针对任意window并搭配一个特定的MyController来特化Widget，这时候就需要模板偏特化。

1 template < class Window >
2 class Widget < Window, MyController>
3 {};

还可以拿任意Button来偏特化：

1 template <class ButtonArg>
2 class Widget<Button<ButtonArg>, MyController>
3 {};

编译器会尝试找出最匹配的定义。但这样的机制不能用在函数身上，无论是成员函数还是非成员函数。

cuigang 2007-12-17 22:12 发表评论

《C++设计新思维》读书笔记（六）

cuigang — Mon, 17 Dec 2007 14:10:00 GMT

2.1 编译期断言

有时候，我们的断言其实在编译时就可以判断真假，于是有编译时断言。例如如此实现：

1 #define STATIC_CHECK(expr) {char unnamed[(expr)?1:0];}

如果条件为假，编译器因大小为0的数组非法而报错。但出错信息显然没有实际意义，可以改进，使用模板：

1 template<bool> struct CompileTimeError;
2 template<> strcut CompileTimeError<true>{};
3 #define STATIC_CHECK(expr) (CompileTimeError<(expr)!=0>())

如果你试着具现化CompileTimeError，编译器会提示“Undefined specialization CompileTimeError”。
（进一步改进从略）

cuigang 2007-12-17 22:10 发表评论

《C++设计新思维》读书笔记（五）

cuigang — Mon, 17 Dec 2007 14:09:00 GMT

1.9 结合Policy Classes

当你将policies组合起来时，便是它们最有用的时候。举例，若我们整打算设计一个泛型的smart pointer。我们分析有两个policies：threading model（多线程模型）和check before dereference （提领前先检验），于是可以这样定义SmartPtr模板类。

1
2 template < Class T,
3 template <class> class CheckingPolicy,
4 template <class> class ThreadingModel
5 >
6 class SmartPtr;

我们可以这样使用：

1
2 typedef SmartPtr<Widget, EnforceNoNull, Singlethreaded> SafeWigetPtr;

或者，

1 typedef SmartPtr<Widget, NoChecking, SingleThread> WidgetPTr;

一旦你设法把一个class分解成正交的policies，便可利用少量的代码涵盖大多数行为。

1.10 以Policy Classes 定制接口

templates的限制之一，你无法定制class的结构，只能定义其行为。而policy-based design支持结构方面的定制。

通过一个结构指针或者引用的聚合，或者依靠于继承。都可以。

1.11 Policies的兼容性

假设有两个SmartPtr：FastWidgetPtr是一个不需要检验的指针，SafeWidgetPtr则必须在提领（dereference）前检验。你能将一个FastWidgetPtr对象指派（赋值）给一个SafeWidgetPtr对象吗？

Policies之间的彼此转换，最好的方法是以Policy来控制SmartPtr对象之间的拷贝和初始化。如：

1 template<Class T, template<class> class CheckingPolicy>
2 class SmartPtr : public CheckingPolicy<T>
3 {
4      //
5      template<class T1, template<class> class CP1>
6      SmartPtr(const SmartPtr<T1, CP1>& other>
7           : pointee_(other.pointee_), CheckingPolicy<T>(other)
8      {//}
9 };

本节后续内容从略

1.12 将一个Class分解为一堆Policies
1.13 摘要

cuigang 2007-12-17 22:09 发表评论

《C++设计新思维》读书笔记（四）

cuigang — Mon, 17 Dec 2007 13:45:00 GMT

1.7 Policy Classes的析构函数

我们已知host class从policy class公有继承。那么将一个指向host class对象的policy class指针delete，将会产生不可预期的结果。解决方法有三：

1、将policy的析构函数声明为虚函数。但这样会妨碍policy的静态连接特性，也会影响执行效率。第一个虚函数的加入会使对象大小带来额外开销。

2、采用protected继承或private继承（派生类指针将不能转化为基类指针，cuigang）。但policy的函数则不能对外访问，失去用户扩充的特性（见1.6节）。

3、定义一个非虚的protected析构函数。（不能对基类指针delete，因为析构函数不可访问，cuigang）

方法3显然没有1、2的副作用。

1.8 通过不完全具现化而获得的选择性机能

更进一步。由于对于模板类中的成员函数，如果未曾用到，那么它就不会被编译器具现出来，有的编译器甚至不对其进行语法检查。如此便导致host class有机会指明并使用policy class的可选特性。如：

1 template < template <class> class CreationPolicy >
2 class WidgetManager : public CreationPolicy<Widget>
3 {
4       //
5       void SwitchPrototype(Widget* pNewPrototype)
6       {
7            CreationPolicy<Widget>& myPolicy = *this;
8            delete myPolicy.GetPrototype();
9            myPolicy.SetPrototype(pNewPrototype);
10       }
11 }

那么

1、如果你采用的CreationPolicy支持GetPrototype()，那么使用WidgetManager::SwitchPrototype()没问题。

2、如果你采用的CreationPolicy不支持GetPrototype()，那么使用WidgetManager::SwitchPrototype()编译出错。

3、如果你采用的CreationPolicy不支持GetPrototype()，但是没有使用WidgetManager::SwitchPrototype()，那么没问题！！！

那么host class的作者就可以利用这种不完整具现化（incomplement instantiation），预定义一些可选的方法。

cuigang 2007-12-17 21:45 发表评论

《C++设计新思维》读书笔记（三）

cuigang — Mon, 17 Dec 2007 13:44:00 GMT

1.5.1 运用Template Template参数实作Policy Classes

如前例，库代码host class如果已知policy class，那么可以这样描述：

1
2 //Library code
3 template < template < class Created > class CreationPolicy >
4 class WidgetManager : public CreationPolicy{};

因为Created只是形式引数（formal argument），不可使用，可以省略如下：

1
2 template < template < class > class CreationPolicy >
3 class WidgetManager : public CreateionPolicy{};

客户代码为：

1 typedef WidgetManager MyWidgetMgr;

当WidgetManager希望在内部以相同的生成策略产生一个内部对象，那么这种template template形式不可或缺。

Policy的确能够带给WidgetManager非常大的弹性。第一，可以外部变更policies。第二，可以自定义policies。

WidgetManager的作者可以定义一些常用的policies，以“template 缺省引数”的方式提供：

1
2 template < template < class > class CreationPolicy = OpNewCreator >
3 class WidgetManager .

1.5.2 运用Template 成员函数实作Policy Classes

我们可以把先前的Creator policy定义为一个非模板类，内部提供一个模板成员函数如下：

1
2 struct OpNewCreator
3 {
4      template < class T >
5      static T* Create()
6      {
7             return new T;
8      }
9 }
10

这种方式对旧式编译期有较佳兼容性。但难以讨论、定义、实作和运用。

1.6 更丰富的Policies

在前例的Creator policy中PrototypeCreateor除了提供Create()成员函数外，还提供了GetProtoType和SetProtoType两个函数，由于WidgetManager继承了policy class，所以WidgetManager具有此两个接口，虽然它自己并没有用。

客户代码可以如此：

1
2 typedef WidgetManager<PrototypeCreator> MyWidgetManager;
3 /////////
4 widget* pPrototype = ;
5 MyWidgetManager mgr;
6 mgr.SetPrototype(pPrototype);

使用者如果需要扩充policies，可以在不影响host class原本功能的前提下，增加接口。“哪个policy被使用”由使用者决定而非程序库自身。policies给与使用者一种能力，在型别安全的前提下扩增host class的功能。

cuigang 2007-12-17 21:44 发表评论

《C++设计新思维》读书笔记（二）

cuigang — Mon, 17 Dec 2007 13:41:00 GMT

《C++设计新思维》读书笔记（二）

1.5 Policies和Policy Classes

举例，定义一个policy生成对象：Creator policy 提供一个Create函数，返回一个指向新生T类型对象的指针。

我们有三种做法：

1 template<class T>
2 struct OpNewCreator{
3      static T* Create(){
4           return New T;
5      }
6 };
7 template <class T>
8 struct MallocCreator{
9      static T* Create(){
10            void* buf = std::malloc(sizeof(T));
11            if(!buf) return 0;
12            return new(buf) T;     //定位new表达式，见《C++ primer》8.4.5， cuigang
13       }
14 };
15 template <class T>
16 struct PrototypeCreator{
17       PrototypeCreator(T* pObj =0):pPrototype_(pObj){}
18       T* Create(){
19             return pPrototype_? pPrototype_->Clone():0;
20       }
21       T* GetPrototype(){ return pPrototype_;}
22       void SetPrototype(T* pObj){pPrototype_ = pObj;}
23 private:
24       T* pPrototype_;
25 };
26

这些实作出来的policy称为policy classes，这个东西并不意图被单独使用，它们主要用于继承或被内含于其它classes。

一个类以复合或继承的方式使用先前定义的三个classes之一，例如

1 //Library code
2 template <class CreationPolicy>
3 class WidgetManager : public CreationPolicy{};

如果class采用一个或多个policies，我们称为hosts或host classes。

客户端如此实例化：

1 //Application code
2 typedef WidgetManager< OpNewCreator<widget> > MywidgetMgr;

让我们分析整个来龙去脉。无论何时，当一个MywidgetMgr对象需要产生一个widget对象时，它便调用它的policy子对象OpNewCreator所提供的Createv()。选择“生成策略”（Creation policy）是WidgetManager使用者的权利。藉由这样的设计，可以让WidgetManager使用者自行装配他所需要的机能。

这便是Policy-based class的设计主旨。

==============================

1 template <class T>
2 void* buf = std::malloc(sizeof(T));
3 void* buf = (void*)new T;

当T为基类，具有派生类时，两者申请的内存大小是不一致的，sizeof(T)不包括 virtual table 的大小。
——钟遥

//////////////////////////////
钟遥过虑了，以下代码

1 struct base{
2         int x;
3         base(){
4                 std::cout<< "create a base."<<std::endl;
5         }
6         virtual void foo(){
7                 std::cout<<"call base"<<std::endl;
8         };
9 };
10 struct test : public base{
11         int y;
12         test(){
13                 std::cout<< "create a test."<<std::endl;
14         }
15         virtual void foo(){
16                 std::cout<<"call test."<<std::endl;
17         }
18         void foo2(){};
19 };
20 /////////////////////////
21         int a = sizeof(test);
22         int b = sizeof(base);
23         std::cout<<"sizeof(test)="<< a << ", "<<"sizeof(base)=" << b << endl;
24         base* pa = new base;
25         base* pb = new test;
26         std::cout<<"---------"<<endl;
27         base* ppa = (base*)malloc(sizeof(base));
28         base* ppb = (base*)malloc(sizeof(test));
29         std::cout<<"---------"<<endl;
30         new(ppa) base;
31         new(ppb) test;
32         pa->foo();
33         pb->foo();
34         ppa->foo();
35         ppb->foo();

输出结果：

1 sizeof(test)=12, sizeof(base)=8
2 create a base.
3 create a base.
4 create a test.
5 ---------
6 ---------
7 create a base.
8 create a base.
9 create a test.
10 call base
11 call test.
12 call base
13 call test.

cuigang 2007-12-17 21:41 发表评论

《C++设计新思维》读书笔记（一）

cuigang — Thu, 13 Dec 2007 16:16:00 GMT

第一篇技术

1 基于Policy的Class设计

1.1 软件设计的多样性

专业软件设计师与新手的最大不同在于，前者知道什么可以有效运作，什么不可以。任何设计结构上的问题，都有许多合适的解法，然而它们各有不同规格并且各有优缺点，对眼前的问题可能合适也可能不合适。白板上可接受的方案，不一定真有实用价值。

设计一个软件系统很困难，因为它不断要求你做抉择。而程序设计犹如人生，抉择是困难的。

1.2 全功能型接口的失败

庞大的classes不能视为成功，因为它们会导致沉重的学习负荷，并且有“非必要之大规模”倾向，使得代码远比手工制作还慢。

理想上，一个良好的设计应该在编译期强制表现出大部分constraints（约束条件、规范）。

1.3 多重继承是救世主？

藉由多重继承来组合多项功能，会产生如下问题：

a.关于技术（mechanics）。目前并没有一成不变即可套用的代码，可以在某种受控情况下将继承而来的classes组合（assemble）起来。大多数时候你得小心协调继承而来的classes的运转，让它们得到所需的行为。

b.关于型别信息（Type information）。Base classes并没有足够的型别信息来继续完成它们的工作。

c.关于状态处理（state manipulation）。base classes实作之各种行为必须操作相同的state（数据）。这意味着它们必须虚继承一个持有该state的base class。由于总是由user classes继承library classes（而非反向），这会使设计更加复杂而且变得没有弹性。

1.4 Templates带来曙光

templates是一种很适合“组合各种行为”的机制，主要因为它们是“依赖使用者提供的型别信息”并且“在编译期才产生”的代码。

和一般的class不同，class templates可以以不同的方式定制。（举例特化）

犹有进者，对于带有多个参数的class templates，你可以采用partial template specialization（偏特化）。（举例）

template的编译期特性以及“可互相组合”特性，使它在设计期非常引人注目。然而一旦你开始尝试实作这些设计，你会遭遇一些不是那么浅白的问题：

a.你无法特化结构，你只能特化其成员函数。

b.成员函数的特化并不能“依理扩张”。（这里指成员函数不具有偏特化行为，cuigang）

c.程序库撰写者不能够提供多笔缺省值。

多重继承和templates两者互补，如果我们将templates和多重继承组合起来，将会产生非常具弹性的设备（device），应该很适合用来产生程序库中的“设计元素”（design elements）。

cuigang 2007-12-14 00:16 发表评论