C++博客-lwch-随笔分类-STL

QCore/Library说明文档

lwch — Tue, 30 Apr 2013 12:24:00 GMT

QCore/Library说明文档

李文超

前言

QCore/Library是一套类STL的类库，它在标准库的范围内删去了不常用的heap、deque等结构（至少我是不常用的）。并为一些容器提供了一些特殊的接口，比如vector中的push_back_unique、add和add_unique等。

Library主要分为六部分，内存调试相关、容器、算法、正则、IO和Graphic，每个模块都有各自的分工，他们之间的耦合度极低，几乎每个模块都可以拆出来独立使用，下面来分别介绍各个模块。

内存调试

我们知道，在C/C++中内存相关的东西是极难控制的，在使用不当时可能造成各种错误，轻则内存泄漏，重则程序崩溃。所以，在生产环境中我们必须通过一个有效的手段来管理好内存。当然，在小块内存频繁new、delete的过程中也会产生大量的内存碎片，从而导致可用内存数量越来越少。应此我们设计了一个内存池来控制小块内存的频繁new、delete，以及做到对内存泄漏的检测。

在内存池的设计之初，我只是简单的设计出了可以使用的MemoryPool的最简版本，它包含一个大块内存的free_list和每个小块内存的chunk_list，当时足以应付大部分的需求，而且最初用的是Visual Leak Detector来检测内存泄漏。但随着时间的推移，想要自己检测内存泄漏的欲望越来越强烈，之后便有了一个use_list来保存内存块的释放情况。当时完成了这个patch之后，兴奋的跑了一下TestCase，然后的结果我想大家应该知道了，一路的飘红，到处是内存泄漏。

经过一天的调试，实在无法容忍的情况下，我翻阅了MSDN，查到了dbghelp.dll中可以通过许多函数来获取调用堆栈，于是在此之下便生产出了CallStack模块。有了它之后你就可以在任意地方保存当前的调用堆栈了，真是十分方便。当然直到现在，它还只支持在Windows下调用堆栈的获取（稍后我会翻阅资料，实现一个like unix的版本，如果可能的话）。

这里不过多的描述实现的细节，具体可以看http://www.cppblog.com/lwch/archive/2012/07/14/183420.html和http://www.cppblog.com/lwch/archive/2013/01/19/197415.html两篇文章。

最后来看allocator，这里只是简单的为其包装了一层。

template

class allocator

{

public:

allocator()

{

}

allocator(const allocator&)

{

}

static T* allocate()

{

MemoryPool* pool = getPool();

return reinterpret_cast(pool->allocate(sizeof(T), free_handler));

}

static T* allocate(size_t n)

{

MemoryPool* pool = getPool();

return reinterpret_cast(pool->allocate(n * sizeof(T), free_handler));

}

static void deallocate(T* p)

{

MemoryPool* pool = getPool();

pool->deallocate(p, sizeof(T));

}

static void deallocate(T* p, size_t n)

{

MemoryPool* pool = getPool();

pool->deallocate(p, n * sizeof(T));

}

static void deallocateWithSize(T* p, size_t n)

{

MemoryPool* pool = getPool();

pool->deallocate(p, n);

}

static T* reallocate(T* p, size_t old_size, size_t n)

{

MemoryPool* pool = getPool();

return pool->reallocate(p, old_size, n * sizeof(T), free_handler);

}

public:

static void(*free_handler)(size_t);

static void set_handler(void(*h)(size_t))

{

free_handler = h;

}

protected:

static MemoryPool* getPool()

{

static MemoryPool pool;

return &pool;

}

};

template

void (*allocator::free_handler)(size_t) = 0;

容器

容器占了Library的大部分，容器的作用是用来存储对象的，容器分为线性和非线性两种。线性的容器有vector、list、string以及用它们作为容器实现的queue、stack四种，非线性的则有rbtree、hashtable以及用它们作为容器实现的set、map、hashset、hashmap六种。对于每种容器，都必须定义出它的value_type、pointer、reference、const_reference、size_type、distance_type、const_iterator、const_reverse_iterator、iterator、reverse_iterator的类型。

所有容器必须包含以下几个接口：size（获取容器内元素个数）、clear（清空容器）、begin（获取[first,last)区间中的first迭代器）、end（获取[first,last)区间中的last迭代器）、rbegin（获取反向的first迭代器）、rend（获取反向的last迭代器）。

traits

traits是一种萃取技术，通过它你可以获取某种类型的一些特性，比如是否含有默认构造函数、拷贝构造函数等。

__type_traits

__type_traits用于萃取出某种类型的一些特性，它的原型如下

template

struct __type_traits

{

typedef __true_type has_default_construct;

typedef __true_type has_copy_construct;

typedef __true_type has_assign_operator;

typedef __true_type has_destruct;

typedef __false_type is_POD;

};

通过特例化，可以定义出所有类型的这些属性，比如char

template <>

struct __type_traits

{

typedef __true_type has_default_construct;

typedef __true_type has_copy_construct;

typedef __true_type has_assign_operator;

typedef __false_type has_destruct;

typedef __true_type is_POD;

};

__container_traits

__container_traits用于萃取出容器的特性，如上文所说的value_type等特性，它的代码很简单

template

struct __container_traits

{

typedef typename T::value_type value_type;

typedef typename T::pointer pointer;

typedef typename T::reference reference;

typedef typename T::const_reference const_reference;

typedef typename T::size_type size_type;

typedef typename T::distance_type distance_type;

typedef typename T::const_iterator const_iterator;

typedef typename T::const_reverse_iterator const_reverse_iterator;

typedef typename T::iterator iterator;

typedef typename T::reverse_iterator reverse_iterator;

};

char_traits

char_traits定义了一些对于Char的操作，包括assign（赋值）、eq（相等）、lt（小于）、compare（比较两个字符串的大小）、length（获取字符串的长度）、move（移动）、copy（拷贝）、assign（字符串赋值）、eof（结束符），它的代码比较简洁，这里不做说明。

type_compare

type_compare用于对两种类型做运行时的匹配，判断所给定的两种类型是否相同。同样通过特例化技术可以很轻松的实现它的代码。

迭代器

迭代器类是一种类似于smart pointer的东西，一般的它都会支持前置和后置的++和--操作，有一些特殊的迭代器同样支持+=和-=操作。当然作为一种smart pointer少不了的是->和*操作，而对于比较操作，则比较的是迭代器所保存的值。

迭代器分为bidirectional_iterator和random_access_iterator两种类型，前者只支持++和--操作而后者支持+和-运算符，之所以会定义出这两种类型是为了提高算法的速度。对于一个迭代器来说同样需要定义value_type、distance_type、pointer、reference、const_pointer、const_reference的类型。

反向迭代器

反向迭代器与正向的正好相反，应此我们可以类似的定义它的++为正向迭代器的--等运算符

iterator_traits

iterator_traits用于萃取出迭代器的所有特性，应此它比较简单

template

struct iterator_traits

{

typedef typename Iterator::value_type value_type;

typedef typename Iterator::distance_type distance_type;

typedef typename Iterator::pointer pointer;

typedef typename Iterator::reference reference;

typedef typename Iterator::const_pointer const_pointer;

typedef typename Iterator::const_reference const_reference;

};

vector

vector是一种比较常用的容器，它的内部是一个连续的内存块，应此它有两个接口分别用于获取内存块已使用的大小和容器的大小，它们是size和capacity，同样它也有一个reserve接口来调整它的容量。由于vector的内部是连续的，应此它只允许从后面插入元素，所以它有push_back、push_back_unique和pop_back方法。当然为了作为queue的容器，我还为其增加了pop_front方法用于删除前端的元素。insert和erase用于在某个地方插入和删除元素，add和add_unique用于插入另一个vector里的内容，而unique则会将容器内重复的元素删除。

当然vector可以像数组一样的使用，它支持方括号的运算符与at接口来获取某个位置上的元素值。

vector容器就先介绍到这里，它的代码你可以在QCore/Library/vector.h中找到。

list

list的内部则是一个双向的链表，应此它在删除前端的元素时会比vector快很多，它的接口基本跟vector相同，这里就不做过多的介绍了。由于vector是内存连续的，所以它可以直接通过索引来访问某个元素，而list是一个双向的链表，应此通过制定索引去访问某个元素时会先看这个索引的值是否小于list长度的一半来决定是从list的头部遍历还是从list的尾部遍历，它的代码你可以在QCore/Library/list.h中找到。

queue和stack

queue是一种FIFO（先进先出）的结构，应此我们建议使用list作为它的容器，通过list的push_back和pop_front可以使代码变的高效。它拥有front和back方法来获取队列中队头和队尾的元素值，同样在插入队列时，你可以不加选择的直接插入或是插入一个不重复的值。

stack是一种FILO（先进后出）的结构，同样它拥有push、push_unique和pop方法以及top和bottom方法用于获取栈顶端和底部的元素值。

对于这两种结构的代码，你可以在QCore/Library/queue.h和QCore/Library/stack.h中找到。

rbtree

rbtree（红黑树）是一棵自平衡的二叉查找树，应此它拥有较高的查找效率，红黑树有以下5条性质

性质1. 节点是红色或黑色。

性质2. 根节点是黑色。

性质3 每个叶节点是黑色的。

性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)

性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

以上摘自百度百科

对于红黑树的每个节点，它都拥有它的key和value，当然我们是按照节点的key来排序的（废话）。红黑树拥有insert_equal和insert_unique方法分别用于插入一个节点，前者允许待插入节点的key已存在于这棵树中，而后者在插入时并不允许这个节点的key已存在于这棵树中，应此它的返回值则是一个二元的。erase方法则提供了对于树中某个节点的删除操作，可以通过迭代器或某个key值来删除其中的节点。

由于红黑树是一棵二叉查找树，应此它应该具备find方法，用于在树中查找某个节点，它返回的则是指向这个节点的一个迭代器。由于红黑树是有序的，应此可以通过maximum和minimum方法得到其中的最大和最小值。通过lower_bound和upper_bound可以得到属于某个key的[first,last]区间，equal_range就是干这个活的，count方法可以得到某个key所对应的节点数。

rbtree就先介绍到这里，稍后我会在博客中继续更新提供更完整的实现方法，它的代码你可以在QCore/Library/rbtree.h中找到。

set和map

set是一种集合的结构，应此在集合中是不允许有重复的元素的，set是以rbtree作为容器的。应此它的insert方法对应于rbtree的insert_unique方法，同样rbtree所具备的接口set也同样拥有，set的key_type与value_type相同，都是给定的类型。

map则是一种key-value的directory结构，应此它的key是不允许重复的，map同样是以rbtree作为容器的。应此它的insert方法同样对应于rbtree的insert_unique方法，在map中除了rbtree的maximum、minimum、lower_bound、upper_bound、equal_range和count没有之外其他接口基本全都拥有，map的key_type是给定的类型，而value_type则是一个以Key和T组成的二元组。

对于这两种结构的代码，你可以在QCore/Library/set.h和QCore/Library/map.h中找到。

hashtable

hashtable是一种哈希结构，应此它的元素查找和插入是非常快的。在这里我用的是吊桶法来处理元素插入时的冲突，当吊桶长度过长（默认是11个元素）时，会将桶的大小翻一倍然后重建整个hashtable以提高hashtable中元素的查找速度。

同样的在hashtable中有insert_equal和insert_unique来分别插入允许相同和不同的元素，当遇到一个已有的元素时会将这个元素插入到第一个与它值相同的节点后面，这样做的好处是可以简单的实现equal_range方法。同时hashtable拥有value方法用于通过一个指定的key来查找到它对应的值，find方法则是用来查找一个key所对应的迭代器的。同样的hashtable也拥有count方法来获取某个key所对应的值的个数，maximum和minimum则是用来获取最大值和最小值的。

hashtable的代码，你可以在QCore/Library/hashtable.h中找到。

hashset和hashmap

hashset和hashmap基本与set和map相同，这里不过多做介绍，关于它们的代码，你可以在QCore/Library/hashset.h和QCore/Library/hashmap.h中找到。

basic_string

basic_string的实现方式基本和vector差不多，为了提高效率，在所有的插入操作中若新的长度的一倍小于一个定长（默认是512）字节时会申请新长度的一倍作为容器的容量。

与vector不同的是basic_string拥有c_str和data方法用于获取字符指针，append方法往字符串尾部链接另一个字符串，assign方法给字符串赋值，find方法查找到第一个指定的字符串的位置，substr则用来获取字符串中一部分的内容。

在basic_string中也有format的静态方法来生成一个指定形式的字符串，其他用法基本与vecotr相同。它的代码，你可以在QCore/Library/string.h中找到。

本章小结

上面介绍了所有的容器的接口和使用方法，以及在实现方式上的一些技巧。希望通过上面的介绍，读者们能够体会到STL为什么需要这么去设计、这么设计的好处是什么。

在我后来做regex的过程中，我深刻的体会到，选用一个合适的数据结构可以给代码的运行效率带来非常大的提升。比如给定NFA某个状态，需要找出所有从这个状态出发的边，之前使用的是map结构来保存从某个状态出发边的vector，之后发现遍历的速度非常缓慢，在换成hashmap之后，速度有显著的提升。应此在实际编程过程中，选用一个合适的数据结构显得尤为重要。

在使用线性结构时，一般在小数据量或不平凡插入或删除数据的情况下，选用vector作为容器会更快一些。而在需要平凡插入或删除数据的场合下，选用list作为容器会有更优异的结果。需要保持元素唯一性的情况下，我会优先选用set作为容器，而在数据量非常大的情况下，就会使用hashset来代替set。map则如它的名字那样，适用于key-value的场合，而hashmap在数据量非常大的情况下使用。

算法

min和max函数分别用于求取最小值和最大值，fill_n用来填充若干个对象的值。copy_backward用来从后往前拷贝值。distance用来求给定区间[first, last)的长度。search用于在给定范围[first1, last1)内查找符合序列[first2, last2)集合的值。swap和iterator_swap分别用于交换两个值和两个迭代器指向的值。sort用于将指定范围[first, last)内的值排序，find用于在指定范围[first, last)内查找指定的值。toArray用于将指定范围[first, last)内的值转换为内存连续的数组，compareArray则用于比较两个数组内的值的个数和值是否相同。

具体的实现代码，你可以在QCore/Library/algo.h中找到。

正则

通过重载+（相加）、-、|、+（前置）、*(前置）、!以及opt函数来生成正则表达式的ε-NFA，然后通过buildDFA函数生成DFA。通过parse和match可分析给定的字符串是否符合这个正则表达式，parse从头开始跑DFA看这个字符串的开头是否有符合这个正则表达式的字符串，而match则会找[first, last)区间内符合这个正则表达式的第一个字符串的相关结果。

具体的实现方法，你可以看http://www.cppblog.com/lwch/archive/2013/02/15/197848.html和http://www.cppblog.com/lwch/archive/2013/02/23/198043.html两篇文章，而代码则可在QCore/Library/regex/regex.h中找到。

IO

IO模块包含文件IO和标准输入输出IO，首先有两个基类分别是basic_istream和basic_ostream分别作为输入和输出stream的基类,其中分别定义了运算符>>和<<，通过这两个运算符可以直观的看到是从stream输出到变量或是从变量输入到stream中。之后有stdstream_basic和fstream_basic都继承自basic_istream和basic_ostream分别作为basic_stdstream和basic_fstream的基类，它们都有open、size、tell、seek、read、write和flush方法，它们都是对底层C函数的一些封装。而在下一层的basic_stdstream和basic_fstream中则实现了运算符>>和<<的所有重载，这样做的好处是可以使代码更有条理性，并方便阅读。

对于标准输入输出流来说，实际上是对stdin、stdout、stderr的一些封装，当然里面也有一些比较特殊的接口，比如setColor（用于设置输入输出流的字体颜色）以及一些颜色相关的函数。

对于fstream来说它是针对所有文件的，应此它会多一个readAll接口用于一次性的读出这个文件的所有内容，为了节省频繁读写磁盘所造成的性能损耗，我们给它定义了两个buffer用来做cache，当你要写入文件时，它并不是马上就直接往磁盘里写的，而会加到buffer当中，当达到一个预值时才真正的写入到磁盘。

那么IO模块就先介绍到这里了，它们的代码你可以在QCore/Library/ios.h、QCore/Library/istream.h、QCore/Library/ostream.h、QCore/Library/fstream.h、QCore/Library/stdstream.h、QCore/Library/iostream.h和QCore/Library/iostream.cpp中找到。

结束

上文介绍了大部分模块的实现过程与实现过程中的心得，让我们来按照顺序回顾一下。

首先介绍了内存池的实现过程，以及在实现过程中遇到的一些问题，比如如何检测内存泄漏、如何获取调用堆栈等。

然后介绍了traits技术，它是用来萃取出一些特性用的，通过traits技术你可以得到一个类型是否为POD是否有默认构造函数等特性。而__container_traits则萃取出了容器的一些特性，比如值类型等等。通过char_traits我们得到了一些关于字符串的操作，比如求字符串的长度等。

之后又通过特例化，我们实现了一种比较两个变量类型是否相同的手段。

接下来我们介绍了迭代器和反向迭代器，它们是一种类似于smart pointer的东西，我们可以通过一个[first, last]前闭后开区间来表示一个容器内的所有元素。然后我们通过iterator_traits萃取出了迭代器的一些特性，比如值类型等。

最后我们介绍了所有比较常用的容器，以及在某些场合下应该使用哪种容器来达到高效的目的。比如在数据量较大时使用hashset要比使用set在插入和查找速度要更快一些，而且时间负责度更稳定一些。

之后我们又介绍了一些常用算法，通过这些算法足以解决一些简单的问题。比如排序和求取一个范围[first, last]的长度等。

在正则这一章中，介绍了我们是如何通过一些运算符的重载来构造出某个正则表达式的状态机的，以及如何通过运行这些状态机来分析给定的字符串。

最后介绍了IO模块，其中分为标准输入输出流和文件流，通过重载<<和>>运算符，可以直观的看到是从流中讲内容输入到一个变量或是从一个变量中讲内容输入到流中。

希望通过本文可使读者体会到作者在设计这个库的时候所考虑的问题，以及对这个库有一个大概的认识，稍后我会在我的博客中补齐所有没有介绍过的模块是如何实现的。

修改记录

2013.4.23第一次编写

2013.4.24添加容器的说明

2013.4.25添加hashtable、hashset、hashmap和basic_string结构的说明

2013.4.28添加算法和正则的说明

2013.4.30添加IO的说明，完结此文

lwch 2013-04-30 20:24 发表评论

山寨STL实现之内存池V2

lwch — Sat, 19 Jan 2013 12:09:00 GMT

在上一篇中我们已经实现了一个简单的内存池，可以申请更大块的内存块来减少申请小块内存块时产生的内存碎片。

在本篇中，我们需要为其加入内存泄漏的检测代码，以此来检测代码编写过程中的疏忽带来的内存泄漏。（callstack的显示暂时仅支持Windows）

一、内存泄漏检测
首先，改写obj和block结构，在obj中加入一个域released表示这个chunk是否被释放

1     struct obj
2     {
3 #ifdef _DEBUG
4         bool      released;
5
6 #if defined(WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__) // Only windows can get callstack
7 #define CALLSTACK_MAX_DEPTH 30
8         UINT_PTR  callStack[CALLSTACK_MAX_DEPTH];
9         DWORD     dwCallStackDepth; // Real depth
10 #endif
11
12 #endif
13         obj*      next;
14     };
15
16     struct block
17     {
18         block*    next;
19         void*     data;
20 #ifdef _DEBUG
21         size_type size;
22 #if defined(WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
23         UINT_PTR  callStack[CALLSTACK_MAX_DEPTH];
24         DWORD     dwCallStackDepth;
25 #endif
26 #endif
27     };

其中的callstack部分将在下一节中介绍

然后，我们增加一个结构

1 #ifdef _DEBUG
2     struct use
3     {
4         obj* data;
5         use* next;
6     };
7 #endif

其中data域指向了一块分配出去的小内存块，next域形成了一张链表。

然后，我们添加一个成员变量来保存这张链表，以及一个函数来将一个chunk插入这张链表

#ifdef _DEBUG
    use*      use_list;
#endif

#ifdef _DEBUG
inline void MemoryPool::addUseInfo(obj* ptr)
{
    use* p = (use*)malloc(sizeof(use));
    p->data = ptr;
    p->next = use_list;
    use_list = p;
}
#endif

然后，我们来改写refill函数使其在分配内存块时打上released标记，并将每个分配的内存块记录下来

1 void* MemoryPool::refill(int i, void(*h)(size_type))
2 {
3     const int count = 20;
4     const int preSize = (i + 1) * ALIGN + headerSize;
5     char* p = (char*)malloc(preSize * count);
6     while(p == 0)
7     {
8         h(preSize * count);
9         p = (char*)malloc(preSize * count);
10     }
11     block* pBlock = (block*)malloc(sizeof(block));
12     while(pBlock == 0)
13     {
14         h(sizeof(block));
15         pBlock = (block*)malloc(sizeof(block));
16     }
17     pBlock->data = p;
18     pBlock->next = free_list;
19     free_list = pBlock;
20
21     obj* current = (obj*)p;
22 #ifdef _DEBUG
23     addUseInfo(current);
24     current->released = false;
25 #endif
26     current = (obj*)((char*)current + preSize);
27     for(int j = 0; j < count - 1; ++j)
28     {
29 #ifdef _DEBUG
30         addUseInfo(current);
31         current->released = true;
32 #endif
33         current->next = chunk_list[i];
34         chunk_list[i] = current;
35         current = (obj*)((char*)current + preSize);
36     }
37     return (char*)p + headerSize;
38 }

其中的headerSize跟callstack有关，将在下一节中介绍。

当然，在deallocate时要将此内存块的released标记打为true

1 void MemoryPool::deallocate(void* p, size_type n)
2 {
3     if(p == 0) return;
4     if(n > MAX_BYTES)
5     {
6         free(p);
7         return;
8     }
9     const int i = INDEX(ROUND_UP(n));
10 #ifdef _DEBUG
11     p = (char*)p - (int)headerSize;
12     obj* ptr = reinterpret_cast(p);
13     if (ptr->released) throw error<char*>("chunk has already released", __FILE__, __LINE__);
14     ptr->released = true;
15 #endif
16     reinterpret_cast(p)->next = chunk_list[i];
17     chunk_list[i] = reinterpret_cast(p);
18 }

OK，现在已经有模有样了，可以松口气了。接下来是最重要的部分，在MemoryPool析构时检测这个Pool内的use_list中是否有chunk的released标记为true（内存泄漏了）

1 MemoryPool::~MemoryPool()
2 {
3 #ifdef _DEBUG
4     while (use_list)
5     {
6         use *ptr = use_list, *next = use_list->next;
7         if (!ptr->data->released)
8         {
9             obj* pObj = ptr->data;
10             Console::SetColor(true, false, false, true);
11             throw error<char*>("chunk leaked", __FILE__, __LINE__);
12         }
13         free(ptr);
14         use_list = next;
15     }
16 #endif
17     clear();
18 }

其实说来也容易，只需要检测每个chunk的released标记是否为true就行了，而最后的clear函数是以前析构函数的代码，用来释放所有申请的block和大块的chunk。

OK，现在我们已经可以检测出没有被deallocate的chunk了。

二、callstack
首先，我们先来看一个Windows API，“CaptureStackBackTrace”这个API通过传入的一个数组来得到一组地址。当然有这个API并不够，我们还需要知道是哪个文件的第几行。“SymGetSymFromAddr64”这个API用来获取某个地址对应的函数名，“SymGetLineFromAddr64”这个API则是用来获取某个地址对应的文件名和行号的，这两个函数的32位版本则是不带64的。有了这些Windows API，我们就可以很轻松的获取到当前函数的调用堆栈了，主要的功劳还是要归功于Windows强大的dbghelp。

最后，完整的代码你可以在http://code.google.com/p/qlanguage/中找到。

lwch 2013-01-19 20:09 发表评论

如何比较两个变量的类型是否相同

lwch — Sat, 25 Aug 2012 08:13:00 GMT

template
        inline const bool compare_type(T1, T2)
        {
            return false;
        }

        template <>
        inline const bool compare_type(int, int)
        {
            return true;
        }

        template <>
        inline const bool compare_type(float, float)
        {
            return true;
        }

        template <>
        inline const bool compare_type(double, double)
        {
            return true;
        }

        template <>
        inline const bool compare_type(char, char)
        {
            return true;
        }

        template <>
        inline const bool compare_type(wchar_t, wchar_t)
        {
            return true;
        }

        template
        inline const bool compare_type(T1*, T2*)
        {
            return compare_type(T1(), T2());
        }

        template
        inline const bool compare_type(const T1*, const T2*)
        {
            return compare_type(T1(), T2());
        }

        template
        inline const bool compare_type(const T1*, T2*)
        {
            return false;
        }

        template
        inline const bool compare_type(T1*, const T2*)
        {
            return false;
        }

通过特例化，我们可以很轻松的查看两个变量的类型是否相同。

lwch 2012-08-25 16:13 发表评论

山寨STL实现之list

lwch — Thu, 09 Aug 2012 13:17:00 GMT

在STL中list是以双向链表的方式来存储的，应此使用给定的下标值来找到对应的节点所需的时间复杂度为O(n)，相比vector直接使用原生指针会慢一些。

因为是双向链表的关系，那么必然有一种结构来表示链表中的节点。

template
        struct __list_node
        {
            __list_node* prev;
            __list_node* next;
            T data;

            __list_node() : prev(NULL), next(NULL)
            {
            }

            __list_node(const T& x) : prev(NULL), next(NULL), data(x)
            {
            }
        };

然后我们定义出其iterator和const_iterator的结构

template
        struct __list_iterator
        {
            typedef __list_iterator iterator;
            typedef T                  value_type;
            typedef ptrdiff_t          difference_type;
            typedef T*                 pointer;
            typedef T&                 reference;
            typedef const T*           const_pointer;
            typedef const T&           const_reference;
            typedef __list_node*    link_type;
            typedef void*              void_pointer;

            link_type node;

            __list_iterator(link_type x) : node(x)
            {
            }

            __list_iterator(const __list_const_iterator& x) : node(x.node)
            {
            }

            __list_iterator() : node(NULL)
            {
            }

            inline iterator& operator++()
            {
                node = ((link_type)node)->next;
                return *this;
            }

            inline iterator operator++(int)
            {
                iterator tmp = *this;
                ++*this;
                return tmp;
            }

            inline iterator& operator--()
            {
                node = ((link_type)node)->prev;
                return *this;
            }

            inline iterator operator--(int)
            {
                iterator tmp = *this;
                --*this;
                return tmp;
            }

            inline reference operator*()const
            {
                return node->data;
            }

            inline bool operator==(const iterator& x)const
            {
                return node == x.node;
            }

            inline bool operator!=(const iterator& x)const
            {
                return node != x.node;
            }
        };

由于const_iterator与iterator的结构类似，这里不再贴出。其中重载了++与--运算符，实际上就是节点的前后移动。

然后看一下list的定义

template
        class list
        {
        }

让我们来看看list中的别名

  public:
            typedef T                        value_type;
            typedef T*                       pointer;
            typedef __list_iterator       iterator;
            typedef __list_const_iterator const_iterator;
            typedef T&                       reference;
            typedef const T&                 const_reference;
            typedef size_t                   size_type;
            typedef ptrdiff_t                difference_type;
            typedef reverse_iterator const_reverse_iterator;
            typedef reverse_iterator reverse_iterator;

下面是其内部的成员变量

  protected:
            typedef __list_node*           link_type;
            typedef list                   self;
            typedef allocator<__list_node > Node_Alloc;

            link_type node;
            size_type length;

在STL中从begin到end总是以一个前闭后开的形式来表示的，应此我们给出一个node节点来表示end所指位置，而node节点的前驱则是这个list的起始节点，而length则存储了这个list的元素数量。

下面来看看list中最基本的构造函数和析构函数

list() : length(0)
            {
                node = Node_Alloc::allocate();
                node->next = node;
                node->prev = node;
            }

            ~list()
            {
                clear();
                Node_Alloc::deallocate(node);
            }

在list对象构造之初，首先构造出node节点，使其的前驱和后继都指向其本身，应此通过begin和end拿出的迭代器为同一个。在list对象析构时，首先将这个list清空，然后将构造出的node节点释放掉。

然后是其begin和end方法，用来获取第一个元素和最后一个元素的后一个元素的迭代器

inline iterator begin()
            {
                return node->next;
            }

            inline const_iterator begin()const
            {
                return node->next;
            }

            inline iterator end()
            {
                return node;
            }

            inline const_iterator end()const
            {
                return node;
            }

front和back分别被用来获取第一个元素和最后一个元素

inline reference front()
            {
                return *begin();
            }

            inline const_reference front()const
            {
                return *begin();
            }

            inline reference back()
            {
                return *end();
            }

            inline const_reference back()const
            {
                return *end();
            }

empty、size分别被用来判别容器是否为空、获取容器内元素的个数

inline bool empty()const
            {
                return length == 0;
            }

            inline size_type size()const
            {
                return length;
            }

list与vector不同的是list是双向的，应此它允许从头尾两个方向来插入和删除元素

inline void push_front(const T& x)
            {
                insert(begin(), x);
            }

            inline void push_back(const T& x)
            {
                insert(end(), x);
            }

            inline void pop_front()
            {
                erase(begin());
            }

            inline void pop_back()
            {
                erase(--end());
            }

然后我们来看一下push的本质，insert函数

iterator insert(const iterator& position, const T& x)
            {
                if(!inRange(position)) throw "out of range";
                link_type tmp = Node_Alloc::allocate();
                construct(tmp, x);
                tmp->prev = position.node->prev;
                tmp->next = position.node;
                position.node->prev->next = tmp;
                position.node->prev = tmp;
                ++length;
                return tmp;
            }

这里首先会检查这个迭代器是否属于这个list，然后构造出一个新节点，并把它插入到这个迭代器的前面，最后将节点数+1。

然后是其删除节点函数erase

  void erase(const iterator& position)
            {
                if(!inRange(position)) throw "out of range";
                position.node->prev->next = position.node->next;
                position.node->next->prev = position.node->prev;
                destruct(&position.node->data, has_destruct(position.node->data));
                Node_Alloc::deallocate(position.node);
                --length;
            }

这里同样会检查这个迭代器是否属于这个list，然后将这个节点移除，最后析构并释放内存空间。

最后让我们来看一下list中重载的运算符

self& operator=(const self& x)
            {
                if(this == &x) return *this;

                iterator first1 = begin();
                iterator last1 = end();
                const_iterator first2 = x.begin();
                const_iterator last2 = x.end();
                while (first1 != last1 && first2 != last2) *first1++ = *first2++;
                if (first2 == last2) erase(first1, last1);
                else insert(last1, first2, last2);
                return *this;
            }

            reference operator[](size_type n)
            {
                if(n < 0 || n >= length) throw "out of range";
                link_type current = NULL;
                if(n < length / 2)
                {
                    current = node->next;
                    for(size_type i = 0; i < n; i++, current = current->next);
                }
                else
                {
                    n = length - n - 1;
                    current = node->prev;
                    for(size_type i = 0; i < n; i++, current = current->prev);
                }
                return current->data;
            }

            inline value_type at(size_type n)
            {
                return operator[](n);
            }

因为其内部使用的是双向链表，应此通过指定下标来获取这个元素是可分别从两头进行移动指针。

至此，list的讲解已完成，完整代码请到http://qlanguage.codeplex.com下载

lwch 2012-08-09 21:17 发表评论

山寨STL实现之内存池

lwch — Sat, 14 Jul 2012 10:40:00 GMT

内存池的作用：
减少内存碎片，提高性能。

首先不得不提的是Win32和x64中对于指针的长度是不同的，在Win32中一个指针占4字节，而在x64中一个指针占8字节。也正是不清楚这一点，当我在x64中将指针作为4字节修改造成其他数据异常。

首先我们先来定义三个宏

  #define ALIGN     sizeof(void*)
            #define MAX_BYTES 128
            #define MAX_COUNT (MAX_BYTES / ALIGN)

正如前面所说的，为了兼容Win32与x64应此我们将要申请的内存按void*的大小来对齐。正如前面所说的，我们认为小于128字节的内存为小内存，会产生内存碎片，应此在申请时应该劲量申请一块较大的内存而将其中的一小块分配给他。

然后让我们来看一下内存池中的成员变量

  struct obj
            {
                obj* next;
            };

            struct block
            {
                block* next;
                void*  data;
            };

            obj*   chunk_list[MAX_COUNT];
            size_t chunk_count;
            block* free_list;

这里使用obj结构来存储已释放内存的列表，这样做的好处是可以更节省内存。在Win32中使用这块内存的前4字节来指向下一个节点，而在x64中使用这块内存的前8字节来指向下一个节点。
chunk_list：保存通过deallocate或refill中释放或是新申请的内存块列表，deallocate和refill将会在下文中介绍。
chunk_count：内存块列表中已有的内存块数量。
free_list：保存了通过malloc申请内存块的链表。

下面我们来看一下内存池的构造函数与析构函数

MemoryPool() : free_list(0), chunk_count(0)
            {
                for(int i = 0; i < MAX_COUNT; ++i) chunk_list[i] = 0;
            }

            ~MemoryPool()
            {
                block* current = free_list;
                while(current)
                {
                    block* next = current->next;
                    free(current->data);
                    free(current);
                    current = next;
                }
            }

构造函数中初始化free_list和chunk_count为0，并初始化chunk_list为一个空列表。而在析构函数中我们必须释放每一块通过malloc申请的大内存块。

接下来是内存的申请

template
            T* allocate(size_t n, void(*h)(size_t))
            {
                if(n == 0) return 0;
                if(n > MAX_BYTES)
                {
                    T* p = (T*)malloc(n);
                    while(p == 0)
                    {
                        h(n);
                        p = (T*)malloc(n);
                    }
                    return p;
                }
                const int i = INDEX(ROUND_UP(n));
                obj* p = chunk_list[i];
                if(p == 0)
                {
                    return refill(i, h);
                }
                chunk_list[i] = p->next;
                return reinterpret_cast(p);
            }

值得注意的是，在调用时必须传入一个函数指针作为参数，当malloc申请内存失败时会去调用这个函数来释放出足够多的内存空间。当要申请的内存大小超过128字节时，调用默认的malloc为其申请内存。否则先查找列表中是否还有足够的空间分配给它，若已没有足够的空间分配给它，则调用refill申请一块大内存。

然后是内存释放函数deallocate

template
            void deallocate(T* p, size_t n)
            {
                if(p == 0) return;
                if(n > MAX_BYTES)
                {
                    free(p);
                    return;
                }
                const int i = INDEX(ROUND_UP(n));
                reinterpret_cast(p)->next = chunk_list[i];
                chunk_list[i] = reinterpret_cast(p);
            }

值得注意的是在释放时必须给出这块内存块的大小。若这块内存大于128字节时，调用默认的free函数释放掉这块内存。否则将其加到对应的chunk_list列表内。

然后是调整内存块大小函数reallocate

template
            T* reallocate(T* p, size_t old_size, size_t new_size, void(*h)(size_t))
            {
                if(old_size > MAX_BYTES && new_size > MAX_BYTES)
                {
                    return realloc(p, new_size);
                }
                if(ROUND_UP(old_size) == ROUND_UP(new_size)) return p;
                T* result = allocate(new_size, h);
                const size_t copy_size = new_size > old_size ? old_size : new_size;
                memcpy(result, p, copy_size);
                deallocate(p, old_size);
                return result;
            }

参数中必须给出这块内存的原始大小和要调整后的大小，同时也必须给出当内存不足时的释放函数的指针。若旧内存块和新内存块的大小都大于128字节时，调用默认的realloc函数重新分配内存。否则先按调整后的大小申请一块内存，并把原来的内容拷贝过来，最后释放掉原来的内存块。这里并不建议使用这个函数，而是手动的去重新申请内存并拷贝释放。

然后来看4个非常简单的计算函数

inline size_t ROUND_UP(size_t bytes)const
            {
                return (bytes + ALIGN - 1) & ~(ALIGN - 1);
            }

            inline size_t ROUND_DOWN(size_t bytes)const
            {
                return bytes & ~(ALIGN - 1);
            }

            inline int INDEX(size_t bytes)const
            {
                return (bytes + ALIGN - 1) / ALIGN - 1;
            }

            inline size_t obj_count(int i)const
            {
                size_t result = 0;
                obj* current = chunk_list[i];
                while(current)
                {
                    ++result;
                    current = current->next;
                }
                return result;
            }

前3个用于内存对齐和计算索引，最后一个用于获取一在空闲列表内一个内存块的数量。

然后是refill函数，用于在没有空闲内存块时申请一块大内存块

template
            T* refill(int i, void(*h)(size_t))
            {
                const int count = 20;
                const int preSize = (i + 1) * ALIGN;
                char* p = (char*)malloc(preSize * count);
                while(p == 0)
                {
                    h(preSize * count);
                    p = (char*)malloc(preSize * count);
                }
                block* pBlock = (block*)malloc(sizeof(block));
                while(pBlock == 0)
                {
                    h(sizeof(block));
                    pBlock = (block*)malloc(sizeof(block));
                }
                pBlock->data = p;
                pBlock->next = free_list;
                free_list = pBlock;
                obj* current = (obj*)(p + preSize);
                for(int j = 0; j < count - 1; ++j)
                {
                    current->next = chunk_list[i];
                    chunk_list[i] = current;
                    current = (obj*)((char*)current + preSize);
                }
                chunk_count += count - 1;
                rebalance();
                return reinterpret_cast(p);
            }

首先申请一个大内存块，然后将这块申请到的内存块放入free_list链表内，最后组织起chunk_list中对应内存卡块的链表，然后重新调整chunk_list列表，最后将申请到的内存块返回。

最后来看一下调整函数rebalance

  void rebalance()
            {
                for(int i = MAX_COUNT - 1; i > 0; --i)
                {
                    const size_t avge = chunk_count / MAX_COUNT;
                    size_t count = obj_count(i);
                    if(count > avge)
                    {
                        const int preSize = ROUND_DOWN((i + 1) * ALIGN / 2);
                        const int j = INDEX(preSize);
                        for(int k = count; k > avge; --k)
                        {
                            obj* chunk = chunk_list[i];
                            chunk_list[i] = chunk_list[i]->next;
                            if(i % 2 == 1)
                            {
                                chunk->next = (obj*)((char*)chunk + preSize);
                                chunk->next->next = chunk_list[j];
                                chunk_list[j] = chunk;
                            }
                            else
                            {
                                chunk->next = chunk_list[j];
                                chunk_list[j] = chunk;
                                obj* next = (obj*)((char*)chunk + preSize);
                                next->next = chunk_list[j + 1];
                                chunk_list[j + 1] = next;
                            }
                            ++chunk_count;
                        }
                    }
                }
            }

这里从后至前查看对应内存块空闲链表的长度，若超过平均数量，则将其切分为2块较小的内存块放入对应的链表内。这样做的好处是可以形成一个金字塔形的分布状况，既越小的内存块大小拥有的节点数量越多，正如本文开头所说，使用内存池是为了解决在申请小块内存时造成的内存碎片。

至此，内存池的讲解已完成，完整的代码请到http://qlanguage.codeplex.com下载

lwch 2012-07-14 18:40 发表评论

山寨STL实现之vector

lwch — Sun, 17 Jun 2012 09:08:00 GMT

首先是vector的定义

template
        class vector
        {
        };

让我们先来看看vector中的一些别名

  public:
            typedef T         value_type;
            typedef T*        pointer;
            typedef T&        reference;
            typedef const T&  const_reference;
            typedef size_t    size_type;
            typedef ptrdiff_t difference_type;
            typedef const T* const_iterator;
            typedef reverse_iterator const_reverse_iterator;
            typedef T* iterator;
            typedef reverse_iterator reverse_iterator;

由上可见，正如上一篇所说，vector的迭代器是由原生的指针来实现的。

下面是其内部的成员变量

  protected:
            typedef vector    self;
            typedef allocator Alloc;

            iterator start;
            iterator finish;
            iterator end_of_element;

start：指向vector的起始地址
finish：指向最后一个元素的后一个元素的地址
end_of_element：指向已申请内存块的结束位置（finish总是小于或等于end_of_element）

在STL中从begin到end总是以一个前闭后开的形式来表示的，形如[begin,end)，这样做的好处是可以使代码写的更简洁：

template
        Iterator find(Iterator first, Iterator last, const T& value)
        {
            while(first != last && *first != value) ++first;
            return first;
        }

下面来看看vector中最基本的构造函数和析构函数

vector() : start(0), finish(0), end_of_element(0)
            {
            }

            ~vector()
            {
                destruct(start, end_of_element);
                if (start != 0) Alloc::deallocate(start, end_of_element - start);
            }

这里将其中的3个成员变量都填充为0。
如上一篇所说，在STL中是将内存分配与对象初始化分开的，同样对象析构与内存释放也是被分开的。

然后是其begin和end方法，用来获取第一个元素和最后一个元素的后一个元素的迭代器。

inline iterator begin()
            {
                return start;
            }

            inline const_iterator begin()const
            {
                return start;
            }

            inline iterator end()
            {
                return finish;
            }

            inline const_iterator end()const
            {
                return finish;
            }

front和back分别被用来获取第一个元素和最后一个元素

inline reference front()
            {
                return *begin();
            }

            inline const_reference front()const
            {
                return *begin();
            }

            inline reference back()
            {
                return *(end() - 1);
            }

            inline const_reference back()const
            {
                return *(end() - 1);
            }

empty、size、capacity分别被用来判别容器是否为空、容器内元素的个数和容器的大小

inline bool empty()const
            {
                return begin() == end();
            }

            inline const size_type size()const
            {
                return size_type(end() - begin());
            }

            inline const size_type capacity()const
            {
                return size_type(end_of_element - begin());
            }

由于在vector的头部插入元素会使所有元素后移，应此它被设计为单向的，只能由尾部插入或移除数据

  void push_back(const T& x)
            {
                if (end_of_element != finish)
                {
                    construct(&*finish, x);
                    ++finish;
                }
                else
                {
                    insert_aux(end(), x);
                }
            }

            inline void pop_back()
            {
                --finish;
                destruct(finish, has_destruct(*finish));
            }

当然从头部移除数据也并非不可以，可以使用erase方法来移除头部的数据，erase方法将会在后面的部分作出说明。

我们先来看一下insert_aux这个方法，在插入元素时几乎都使用到了这个方法。

  void insert_aux(const iterator position, const T& x)
            {
                if(finish != end_of_element)
                {
                    construct(&*finish, *(finish - 1));
                    T x_copy = x;
                    copy_backward(position, finish - 1, finish);
                    *position = x_copy;
                    ++finish;
                }
                else
                {
                    const size_type old_size = size();
                    const size_type new_size = old_size == 0 ? 2 : old_size * 2;
                    iterator tmp = Alloc::allocate(new_size);
                    uninitialized_copy(begin(), position, tmp);
                    iterator new_position = tmp + (position - begin());
                    construct(&*new_position, x);
                    uninitialized_copy(position, end(), new_position + 1);
                    destruct(begin(), end());
                    Alloc::deallocate(begin(), old_size);
                    end_of_element = tmp + new_size;
                    finish = tmp + old_size + 1;
                    start = tmp;
                }
            }

在容器还有足够的空间时，首先将从position位置到finish位置的元素整体后移一个位置，最后将要被插入的元素写入到原position的位置同时改变finish指针的值。
若空间不足时，首先根据原有空间的大小的一倍来申请内存，然后将元素从原有位置的begin到position拷贝到新申请的内存中，然后在新申请内存的指定位置插入要插入的元素值，最后将余下的部分也拷贝过来。然后将原有元素析构掉并把内存释放掉。

为何不使用reallocate?
reallocate的本意并不是在原有内存的位置增加或减少内存，reallocate首先会试图在原有的内存位置增加或减少内存，若失败则会重新申请一块新的内存并把原有的数据拷贝过去，这种操作本质上等价于重新申请一块内存，应此这里使用的是allocate而并非reallocate。

然后让我们来看一下insert和erase方法

inline iterator insert(iterator position, const T& x)
            {
                const size_type pos = position - begin();
                if(finish != end_of_element && position == end())
                {
                    construct(&*finish, x);
                    ++finish;
                }
                else insert_aux(position, x);
                return begin() + pos;
            }

            iterator erase(iterator position)
            {
                destruct(position, has_destruct(*position));
                if (position + 1 != end())
                {
                    copy(position + 1, end(), position);
                }
                --finish;
                return position;
            }

若是要在最后插入一个元素且容器的剩余空间还足够的话，直接将元素插入到finish的位置，并将finish指针后移一位即可。若容器空间不够或不是插在最后一个的位置，则调用insert_aux重新分配内存或插入。
删除时首先析构掉原有元素，若被删元素不是最后一个元素，则将后面的所有元素拷贝过来，最后将finish指针前移一个位置。

最后让我们来看一下其中重载的运算符

self& operator=(const self& x)
            {
                if(&x == this) return *this;
                size_type const other_size = x.size();
                if(other_size > capacity())
                {
                    destruct(start, finish);
                    Alloc::deallocate(start, capacity());
                    start = Alloc::allocate(other_size);
                    finish = uninitialized_copy(x.begin(), x.end(), start);
                    end_of_element = start + other_size;
                }
                else
                {
                    finish = uninitialized_copy(x.begin(), x.end(), start);
                }
                return *this;
            }

            inline reference operator[](size_type n)
            {
                return *(begin() + n);
            }

            inline value_type at(size_type n)
            {
                return *(begin() + n);
            }

由于vector内部用的是原生的指针，应此这些运算符的使用方式和原生指针的并无差异。值得注意的是在做赋值操作时会产生内存的重新分配与拷贝操作。

至此，vector的讲解已完成，完整的代码请到http://qlanguage.codeplex.com下载

lwch 2012-06-17 17:08 发表评论

山寨STL实现之traits,construct&destruct

lwch — Sat, 02 Jun 2012 14:39:00 GMT

traits技术被广泛应用于STL中，通过它您可以轻松的萃取出一个对象的特性。在STL中也是通过它来实现性能的最优化，比如一个对象是个POD对象(Plain Old Data)，则在拷贝过程中直接可以通过memcpy等函数拷贝，而无需调用拷贝构造函数或operator=。

先来看看STL中最基本的对象iterator

template
        struct iterator
        {
            typedef T                               value_type;
            typedef Difference                      difference_type;
            typedef T*                              pointer;
            typedef T&                              reference;
            typedef const T*                        const_pointer;
            typedef const T&                        const_reference;
            typedef iterator   self;
        };

        template
        struct const_iterator : public iterator
        {
        };

由以上代码可知，对于每一个iterator必须定义其value_type,size_type,difference_type,pointer,reference,const_pointer,const_reference和self类型。
一、value_type
value_type指示了该迭代器所保存的值类型
二、difference_type
difference_type用来指示两个迭代器之间的距离类型
三、pointer,reference,const_pointer,const_reference
分别是所指之物的指针,引用,指针常量和引用常量的类型
四、self
self为该迭代器自身的类型

下面来看一下iterator_traits，iterator_traits主要用来萃取迭代器iterator的值类型等

template
        struct iterator_traits
        {
            typedef typename Iterator::value_type      value_type;
            typedef typename Iterator::difference_type difference_type;
            typedef typename Iterator::pointer         pointer;
            typedef typename Iterator::reference       reference;
            typedef typename Iterator::const_pointer   const_pointer;
            typedef typename Iterator::const_reference const_reference;
            typedef typename Iterator::self            self_type;
        };

这里有一点可以提前预告一下，vector作为一个容器，其内部是使用指针作为迭代器的，那么我们如何萃取出它的值类型等呢？
答案很简单，特例化，那么我们就来为iterator_traits分别做两种T*和const T*的特例化

template
        struct iterator_traits
        {
            typedef T         value_type;
            typedef ptrdiff_t difference_type;
            typedef T*        pointer;
            typedef T&        reference;
            typedef const T*  const_pointer;
            typedef const T&  const_reference;
            typedef T*        self_type;
        };

        template
        struct iterator_traits<const T*>
        {
            typedef T         value_type;
            typedef ptrdiff_t difference_type;
            typedef T*        pointer;
            typedef T&        reference;
            typedef const T*  const_pointer;
            typedef const T&  const_reference;
            typedef const T*  self_type;
        };

至此，我们可以用iterator_traits萃取出每种iterator的值类型等内容了。

之前已经说到了，通过traits可以萃取出一些对象的特性，从而提高代码的效率。事实确实如此，通过traits可萃取出一个对象是否是一个POD对象，对于一个POD对象，我们在拷贝时，不应该使用其拷贝构造函数或是operator=，而用memcpy则效率更高。
下面我们来看一下__type_traits

  struct __true_type
        {
        };

        struct __false_type
        {
        };

        template
        struct __type_traits
        {
            typedef __false_type has_default_construct;
            typedef __false_type has_copy_construct;
            typedef __false_type has_assign_operator;
            typedef __false_type has_destruct;
            typedef __false_type is_POD;
        };

不得不提的是其中分别用__true_type和__false_type来表示是否存在这个特性。

那么我们如何萃取出基础类型诸如int,char等的特性呢？
答案依然是特例化，这里代码不再贴出，文末会给出完整代码的详细地址。

最后我们使用一个hash_destruct的函数来获取出这个类型是否有析构函数。

template
        inline auto has_destruct(const T&)->decltype(static_cast<__type_traits::has_destruct*>(0))
        {
            return static_cast::has_destruct*>(0);
        }

        template
        inline auto has_destruct(T*)->decltype(static_cast<__type_traits::has_destruct*>(0))
        {
            static_assert(false, "Please use const T& not T*");
            return static_cast::has_destruct*>(0);
        }

        template
        inline auto has_destruct(const T*)->decltype(static_cast<__type_traits::has_destruct*>(0))
        {
            static_assert(false, "Please use const T& not const T*");
            return static_cast::has_destruct*>(0);
        }

不得不提的是C++0x的确很强大，可以通过形参来确定返回值的类型，这样我们就可以萃取出这个类型的has_destruct域是__true_type或是__false_type了。

最后来看看construct和destruct的代码，在STL中对象的内存分配和构造是被分开的，对于基础对象int,char等，在析构时我们无需调用其析构函数。
下面来看construct和destruct的实现

template
        inline void construct(T1* p, const T2& value)
        {
            new (p) T1(value);
        }

        template
        inline void destruct(T* p, __true_type*)
        {
            p->~T();
        }

        template
        inline void destruct(T*, __false_type*)
        {
        }

        template
        inline void destruct(ForwardIterator first, ForwardIterator last)
        {
            while(first != last)
            {
                destruct(first, has_destruct(*first));
                ++first;
            }
        }

至此，关于traits技术和construct及destruct的讲解已完成，完整的代码请到http://qlanguage.codeplex.com/下载

lwch 2012-06-02 22:39 发表评论

山寨STL实现之allocator

lwch — Sun, 20 May 2012 13:45:00 GMT

作为一个山寨的STL，那么不得不提的是其中的allocator（空间配置器）。顾名思义，它是负责空间分配用的，下面代码十分简单，仅对C函数malloc和free进行了薄薄的一层封装，同时给定了自定义函数free_handler用于在空间分配时候由于内存被占满了而导致的分配失败。

这里值得注意的是：这个释放函数的函数指针应该是由调用方来负责指定，并且它仅有一个参数表明至少需要释放多少字节的内存。

下面来看代码，代码非常简单，应此这里就不逐一展开说明了。

#ifndef _QLANGUAGE_LIBRARY_ALLOC_H_
#define _QLANGUAGE_LIBRARY_ALLOC_H_

#if 0
#include <new>
#define __THROW_BAD_ALLOC throw std::bad_alloc
#elif !defined(__THROW_BAD_ALLOC)
#include <iostream>
#define __THROW_BAD_ALLOC std::cerr << "out of memory" << std::endl; exit(1)
#endif

namespace QLanguage
{
    namespace Library
    {
        template <typename T>
        class allocator
        {
        public:
            allocator()
            {
            }

            allocator(const allocator<T>&)
            {
            }

            static T* allocate()
            {
                const size_t size = sizeof(T);
                T* result = (T*)malloc(size);
                while(result == nullptr)
                {
                    if(free_handler) free_handler(size);
                    else __THROW_BAD_ALLOC;
                    result = (T*)malloc(size);
                }
                return result;
            }

            static T* allocate(const size_t& n)
            {
                const size_t size = n * sizeof(T);
                if(size <= 0) throw "bad allocate size";
                T* result = (T*)malloc(size);
                while(result == nullptr)
                {
                    if(free_handler) free_handler(size);
                    else __THROW_BAD_ALLOC;
                    result = (T*)malloc(size);
                }
                return result;
            }

            static void deallocate(T* p)
            {
                free(p);
            }

            static void deallocate(T* p, const size_t&)
            {
                free(p);
            }

            static T* reallocate(T* p, const size_t& n)
            {
                const size_t size = n * sizeof(T);
                if(size <= 0) throw "bad reallocate size";
                T* result = (T*)realloc(p, size);
                while(result == nullptr)
                {
                    if(free_handler) free_handler(size);
                    else __THROW_BAD_ALLOC;
                    result = (T*)realloc(p, size);
                }
                return result;
            }
        public:
            static void(*free_handler)(const size_t&);

            static void set_handler(void(*h)(const size_t&))
            {
                free_handler = h;
            }
        };

        template <typename T>
        typename void (*allocator<T>::free_handler)(const size_t&) = nullptr;
    }
}

#endif

完整代码请到http://qlanguage.codeplex.com/下载

lwch 2012-05-20 21:45 发表评论

山寨STL实现笔记

lwch — Sun, 20 May 2012 12:08:00 GMT

数据结构
1. allocator
2. 内存池
3. 内存池V2
4. traits,construct&destruct
5. vector
6. list
7. rbtree
8. map&set
9. hashtable
10. hash_map&hash_set
算法

lwch 2012-05-20 20:08 发表评论