C++博客-cuigang-文章分类-《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 发表评论