极品日韩av,亚洲一区二区免费视频,亚洲成人影音

QCore/Library说明文档

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

QCore/Library说明文档

李文��?

前言

QCore/Library是一套类STL的类库，它在标准库的范围内删��M��不常用的heap、deque�{�结构（臛_��我是不常用的�Q�。�ƈ��Z��些容器提供了一些特�D�的接口�Q�比如vector中的push_back_unique、add和add_unique�{��?

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

内存调试

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

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

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

�q�里不过多的描述实现的细节，具体可以�?a href="http://www.shnenglu.com/lwch/archive/2012/07/14/183420.html">http://www.shnenglu.com/lwch/archive/2012/07/14/183420.html�?a href="http://www.shnenglu.com/lwch/archive/2013/01/19/197415.html">http://www.shnenglu.com/lwch/archive/2013/01/19/197415.html两篇文章�?

最后来看allocator�Q�这里只是简单的为其包装了一层�?

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的大部分�Q�容器的作用是用来存储对象的�Q�容器分为线性和非线性两�U�。线性的容器有vector、list、string以及用它们作为容器实现的queue、stack四种�Q�非�U�性的则有rbtree、hashtable以及用它们作为容器实现的set、map、hashset、hashmap六种。对于每�U�容器，都必��d��义出它的value_type、pointer、reference、const_reference、size_type、distance_type、const_iterator、const_reverse_iterator、iterator、reverse_iterator的类型�?

所有容器必��d��含以下几个接口：size�Q�获取容器内元素个数�Q�、clear�Q�清�I�容器）、begin�Q�获取[first,last)区间中的first�q�代器）、end�Q�获取[first,last)区间中的last�q�代器）、rbegin�Q�获取反向的first�q�代器）、rend�Q�获取反向的last�q�代器）�?

traits

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

__type_traits

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

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;

};

通过特例化，可以定义出所有类型的�q�些属性，比如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�Q�赋��|��、eq�Q�相�{�）、lt�Q�小于）、compare�Q�比较两个字�W�串的大��）、length�Q�获取字�W�串的长度）、move�Q�移动）、copy�Q�拷贝）、assign�Q�字�W�串赋��|��、eof�Q�结束符�Q�，它的代码比较��z�，�q�里不做说明�?

type_compare

type_compare用于对两�U�类型做�q�行时的匚w��Q�判断所�l�定的两�U�类型是否相同。同样通过特例化技术可以很��L��的实现它�?a href="../Source/QCore/Library/traits.h">代码�?

�q�代�?

�q�代器类是一�U�类��g��smart pointer的东西，一般的它都会支持前�|�和后置�?+�?-操作�Q�有一些特�D�的�q�代器同��h��?=�?=操作。当然作��Z��U�smart pointer��不了的�?>�?操作�Q�而对于比较操作，则比较的是�P代器所保存的倹{�?

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

反向�q�代�?

反向�q�代器与正向的正好相反，应此我们可以�c�M��的定义它�?+为正向�P代器�?-�{�运��符

iterator_traits

iterator_traits用于萃取��P代器的所有特性，应此它比较简�?

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

当然vector可以像数�l�一��L��使用�Q�它支持�Ҏ��L��q�算�W�与at接口来获取某个位�|�上的元素倹{�?

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

list

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

queue和stack

queue是一�U�FIFO�Q�先�q�先出）的结构，应此我们��使用list作�ؓ它的容器�Q�通过list的push_back和pop_front可以使代码变的高效。它拥有front和back�Ҏ��来获取队列中队头和队��元素��|��同样在插入队列时�Q�你可以不加选择的直接插入或是插入一个不重复的倹{�?

stack是一�U�FILO�Q�先�q�后出）的结构，同样它拥有push、push_unique和pop�Ҏ��以及top和bottom�Ҏ��用于获取栈顶端和底部的元素倹{�?

对于�q�两�U�结构的代码�Q�你可以�?a href="../Source/QCore/Library/queue.h">QCore/Library/queue.h�?a href="../Source/QCore/Library/stack.h">QCore/Library/stack.h中找到�?

rbtree

rbtree�Q�红黑树�Q�是一��自�q��的二叉查找树�Q�应此它拥有较高的查找效率，�U�黑树有以下5条性质

性质1. 节点是红色或黑色�?

性质2. 根节�Ҏ��黑色�?

性质3 每个叶节�Ҏ��黑色的�?

性质4 每个�U�色节点的两个子节点都是黑色�?从每个叶子到根的所有�\径上不能有两个连�l�的�U�色节点)

性质5. 从�Q一节点到其每个叶子的所有�\径都包含相同数目的黑色节炏V�?

以上摘自癑ֺ�癄��

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

�׃��U�黑树是一��二叉查找树�Q�应此它应该具备find�Ҏ��Q�用于在树中查找某个节点�Q�它�q�回的则是指向这个节点的一个�P代器。由于红黑树是有序的�Q�应此可以通过maximum和minimum�Ҏ��得到其中的最大和最��倹{��通过lower_bound和upper_bound可以得到属于某个key的[first,last]区间�Q�equal_range��是�q�这个活的，count�Ҏ��可以得到某个key所对应的节�Ҏ��?

rbtree��先介绍到这里，�E�后我会在博客中�l�箋更新提供更完整的实现�Ҏ��Q�它的代码你可以�?a href="../Source/QCore/Library/rbtree.h">QCore/Library/rbtree.h中找到�?

set和map

set是一�U�集合的�l�构�Q�应此在集合中是不允许有重复的元素的�Q�set是以rbtree作�ؓ容器的。应此它的insert�Ҏ��对应于rbtree的insert_unique�Ҏ��Q�同样rbtree所具备的接口set也同��h��有，set的key_type与value_type相同�Q�都是给定的�c�d��?

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

对于�q�两�U�结构的代码�Q�你可以�?a href="../Source/QCore/Library/set.h">QCore/Library/set.h�?a href="../Source/QCore/Library/map.h">QCore/Library/map.h中找到�?

hashtable

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

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

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

hashset和hashmap

hashset和hashmap基本与set和map相同�Q�这里不�q�多做介�l�，关于它们的代码，你可以在QCore/Library/hashset.h�?a href="../Source/QCore/Library/hashmap.h">QCore/Library/hashmap.h中找到�?

basic_string

basic_string的实现方式基本和vector差不多，��Z��提高效率�Q�在所有的插入操作中若新的长度的一倍小于一个定长（默认�?12�Q�字节时会申��h��长度的一倍作为容器的定w��?

与vector不同的是basic_string拥有c_str和data�Ҏ��用于获取字符指针�Q�append�Ҏ��往字符串尾部链接另一个字�W�串�Q�assign�Ҏ��l�字�W�串赋��|��find�Ҏ��查找到第一个指定的字符串的位置�Q�substr则用来获取字�W�串中一部分的内宏V�?

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

本章��结

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

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

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

��法

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

具体的实��C��码，你可以在QCore/Library/algo.h中找到�?

正则

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

具体的实现方法，你可以看http://www.shnenglu.com/lwch/archive/2013/02/15/197848.html�?a href="http://www.shnenglu.com/lwch/archive/2013/02/23/198043.html">http://www.shnenglu.com/lwch/archive/2013/02/23/198043.html两篇文章�Q�而代码则可在QCore/Library/regex/regex.h中找到�?

IO

IO模块包含文�gIO和标准输入输出IO�Q�首先有两个基类分别是basic_istream和basic_ostream分别作�ؓ输入和输出stream的基�c?其中分别定义了运��符>>�?lt;<�Q�通过�q�两个运��符可以直观的看到是从stream输出到变量或是从变量输入到stream中。之后有stdstream_basic和fstream_basic都��承自basic_istream和basic_ostream分别作�ؓbasic_stdstream和basic_fstream的基�c�，它们都有open、size、tell、seek、read、write和flush�Ҏ��Q�它们都是对底层C函数的一些封装。而在下一层的basic_stdstream和basic_fstream中则实现了运��符>>�?lt;<的所有重载，�q�样做的好处是可以��代码更有条理性，�q�方侉K��诅R�?

对于标准输入输出��来��_��实际上是对stdin、stdout、stderr的一些封装，当然里面也有一些比较特�D�的接口�Q�比如setColor�Q�用于设�|�输入输出流的字体颜�Ԍ��以及一些颜色相关的函数�?

对于fstream来说它是针对所有文件的�Q�应此它会多一个readAll接口用于一�ơ性的��d��q�个文�g的所有内容，��Z��节省频繁��d��盘所造成的性能损耗，我们�l�它定义了两个buffer用来做cache�Q�当你要写入文�g�Ӟ��它�ƈ不是马上��q��接往��盘里写的，而会加到buffer当中�Q�当辑ֈ�一个预值时才真正的写入到磁盘�?

那么IO模块��先介绍到这里了�Q�它们的代码你可以在QCore/Library/ios.h�?a href="../Source/QCore/Library/istream.h">QCore/Library/istream.h�?a href="../Source/QCore/Library/ostream.h">QCore/Library/ostream.h�?a href="../Source/QCore/Library/fstream.h">QCore/Library/fstream.h�?a href="../Source/QCore/Library/stdstream.h">QCore/Library/stdstream.h�?a href="../Source/QCore/Library/iostream.h">QCore/Library/iostream.h�?a href="../Source/QCore/Library/iostream.cpp">QCore/Library/iostream.cpp中找到�?

�l�束

上文介绍了大部分模块的实现过�E�与实现�q�程中的心得�Q�让我们来按照顺序回��一下�?

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

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

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

接下来我们介�l�了�q�代器和反向�q�代器，它们是一�U�类��g��smart pointer的东西，我们可以通过一个[first, last]前闭后开区间来表�C�Z��个容器内的所有元素。然后我们通过iterator_traits萃取��Z��q�代器的一些特性，比如值类型等�?

最后我们介�l�了所有比较常用的容器�Q�以及在某些场合下应该��用哪�U�容器来辑ֈ�高效的目的。比如在数据量较大时使用hashset要比使用set在插入和查找速度要更快一些，而且旉��负责度更�E�_��一些�?

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

在正则这一章中�Q�介�l�了我们是如何通过一些运��符的重载来构造出某个正则表达式的状态机的，以及如何通过�q�行�q�些状态机来分析给定的字符丌Ӏ?

最后介�l�了IO模块�Q�其中分为标准输入输出流和文件流�Q�通过重蝲<<�?gt;>�q�算�W�，可以直观的看到是从流中讲内容输入��C��个变量或是从一个变量中讲内容输入到��中�?

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

修改记录

2013.4.23�W�一�ơ编�?

2013.4.24��d��容器的说�?

2013.4.25��d��hashtable、hashset、hashmap和basic_string�l�构的说�?

2013.4.28��d��法和正则的说明

2013.4.30��d��IO的说明，完结此文

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

山寨STL实现之内存池V2

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

�?a href="http://www.shnenglu.com/lwch/archive/2012/07/14/183420.html" target="_blank">上一��中我们已经实现了一个简单的内存池，可以甌��更大块的内存块来减少甌��块内存块时产生的内存碎片�?br />
在本��中�Q�我们需要�ؓ其加入内存泄漏的��代码，以此来检��代码编写过�E�中的疏忽带来的内存泄漏。（callstack的显�C�暂时仅支持Windows�Q?br />
一、内存泄漏检��?/strong>
首先�Q�改写obj和block�l�构�Q�在obj中加入一个域released表示�q�个chunk是否被释�?br />
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部分��在下一节中介绍

然后�Q�我们增加一个结�?br />
1 #ifdef _DEBUG
2     struct use
3     {
4         obj* data;
5         use* next;
6     };
7 #endif
其中data域指向了一块分配出�ȝ��内存块�Q�next域�Ş成了一张链表�?br />
然后�Q�我们添加一个成员变量来保存�q�张链表�Q�以及一个函数来��一个chunk插入�q�张链表

#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

然后�Q�我们来改写refill函数使其在分配内存块时打上released标记�Q��ƈ��每个分配的内存块记录下�?br />
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有关�Q�将在下一节中介绍�?br />
当然�Q�在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�Q�现在已�l�有模有样了�Q�可以松口气了。接下来是最重要的部分，在MemoryPool析构时检��这个Pool内的use_list中是否有chunk的released标记为true�Q�内存泄漏了�Q?br />
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��p��了，而最后的clear函数是以前析构函数的代码�Q�用来释放所有申��L��block和大块的chunk�?br />
OK�Q�现在我们已�l�可以检��出没有被deallocate的chunk了�?br />
二、callstack
首先�Q�我们先来看一个Windows API�Q?#8220;CaptureStackBackTrace”�q�个API通过传入的一个数�l�来得到一�l�地址。当然有�q�个API�q�不够，我们�q�需要知道是哪个文�g的第几行�?#8220;SymGetSymFromAddr64”�q�个API用来获取某个地址对应的函数名�Q?#8220;SymGetLineFromAddr64”�q�个API则是用来获取某个地址对应的文件名和行��L��Q�这两个函数�?2位版本则是不�?4的。有了这些Windows API�Q�我们就可以很轻杄��获取到当前函数的调用堆栈了，主要的功劌��是要归功于Windows强大的dbghelp�?br />
最后，完整的代码你可以�?a target="_blank">http://code.google.com/p/qlanguage/中找到�?img src ="http://www.shnenglu.com/lwch/aggbug/197415.html" width = "1" height = "1" />

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;
        }
通过特例化，我们可以很轻杄��查看两个变量的类型是否相同�?img src ="http://www.shnenglu.com/lwch/aggbug/188253.html" width = "1" height = "1" />

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

山寨STL实现之list

lwch — Thu, 09 Aug 2012 13:17:00 GMT
在STL中list是以双向链表的方式来存储的，应此使用�l�定的下标值来扑ֈ�对应的节�Ҏ��需的时间复杂度为O(n)�Q�相比vector直接使用原生指针会慢一些�?br />
因�ؓ是双向链表的关系�Q�那么必然有一�U�结构来表示链表中的节点�?br />
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的结�?br />
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的结构类��|��q�里不再贴出。其中重载了++�?-�q�算�W�，实际上就是节点的前后�U�d��?br />
然后看一下list的定�?br />
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;

下面是其内部的成员变�?br />
  protected:
            typedef __list_node*           link_type;
            typedef list                   self;
            typedef allocator<__list_node > Node_Alloc;

            link_type node;
            size_type length;
在STL中从begin到end��L��以一个前闭后开的�Ş式来表示的，应此我们�l�出一个node节点来表�C�end所指位�|�，而node节点的前驱则是这个list的�v始节点，而length则存储了�q�个list的元素数量�?br />
下面来看看list中最基本的构造函数和析构函数

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

            ~list()
            {
                clear();
                Node_Alloc::deallocate(node);
            }
在list对象构造之初，首先构造出node节点�Q��其的前驱和后�l�都指向其本�w�，应此通过begin和end拿出的�P代器为同一个。在list对象析构�Ӟ��首先��这个list清空�Q�然后将构造出的node节点释放掉�?br />
然后是其begin和end�Ҏ��Q�用来获取第一个元素和最后一个元素的后一个元素的�q�代�?br />
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分别被用来获取第一个元素和最后一个元�?br />
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分别被用来判别容器是否�ؓ�I�、获取容器内元素的个�?br />
inline bool empty()const
            {
                return length == 0;
            }

            inline size_type size()const
            {
                return length;
            }

list与vector不同的是list是双向的�Q�应此它允许从头��两个方向来插入和删除元�?br />
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;
            }
�q�里首先会检查这个�P代器是否属于�q�个list�Q�然后构造出一个新节点�Q��ƈ把它插入到这个�P代器的前面，最后将节点�?1�?br />
然后是其删除节点函数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;
            }
�q�里同样会检查这个�P代器是否属于�q�个list�Q�然后将�q�个节点�U�除�Q�最后析构�ƈ释放内存�I�间�?br />
最后让我们来看一下list中重载的�q�算�W?br />
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);
            }
因�ؓ其内部��用的是双向链表，应此通过指定下标来获取这个元素是可分别从两头�q�行�U�d��指针�?br />
��x��Q�list的讲解已完成�Q�完整代码请�?a target="_blank">http://qlanguage.codeplex.com下蝲

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

山寨STL实现之内存池

lwch — Sat, 14 Jul 2012 10:40:00 GMT
内存池的作用�Q?br /> 减少内存��片�Q�提高性能�?br />
首先不得不提的是Win32和x64中对于指针的长度是不同的�Q?strong>在Win32中一个指针占4字节�Q�而在x64中一个指针占8字节。也正是不清楚这一点，当我在x64中将指针作�ؓ4字节修改造成其他数据异常�?br />
首先我们先来定义三个�?br />

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

正如前面所说的�Q��ؓ了兼容Win32与x64应此我们��要甌��的内存按void*的大��来寚w��。正如前面所说的�Q�我们认为小�?28字节的内存�ؓ��内存，会��生内存碎片，应此在申��h��应该劲量甌��一块较大的内存而将其中的一��块分配�l�他�?br />
然后让我们来看一下内存池中的成员变量

  struct obj
            {
                obj* next;
            };

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

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

�q�里使用obj�l�构来存储已释放内存的列表，�q�样做的好处是可以更节省内存。在Win32中��用这块内存的�?字节来指向下一个节点，而在x64中��用这块内存的�?字节来指向下一个节炏V�?br /> chunk_list�Q�保存通过deallocate或refill中释放或是新甌��的内存块列表�Q�deallocate和refill��会在下文中介绍�?br /> chunk_count�Q�内存块列表中已有的内存块数量�?br /> free_list�Q�保存了通过malloc甌��内存块的链表�?br />
下面我们来看一下内存池的构造函��C��析构函数

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

构造函��C��初始化free_list和chunk_count�?�Q��ƈ初始化chunk_list��Z��个空列表。而在析构函数中我们必��释放每一块通过malloc甌��的大内存块�?br />
接下来是内存的申�?br />

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

值得注意的是�Q�在调用时必��M��入一个函数指针作为参敎ͼ�当malloc甌��内存��p�|时会去调用这个函数来释放��够多的内存空间。当要申��L��内存大小��过128字节�Ӟ��调用默认的malloc为其甌��内存。否则先查找列表中是否还有��够的�I�间分配�l�它�Q�若已没有��够的�I�间分配�l�它�Q�则调用refill甌��一块大内存�?br />
然后是内存释攑և�数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);
            }

值得注意的是在释放时必须�l�出�q�块内存块的大小。若�q�块内存大于128字节�Ӟ��调用默认的free函数释放掉这块内存。否则将其加到对应的chunk_list列表内�?br />
然后是调整内存块大小函数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;
            }

参数中必��ȝ��块内存的原始大小和要调整后的大小�Q�同时也必须�l�出当内存不��x��的释攑և�数的指针。若旧内存块和新内存块的大小都大�?28字节�Ӟ��调用默认的realloc函数重新分配内存。否则先按调整后的大��申请一块内存，�q�把原来的内�Ҏ��贝过来，最后释放掉原来的内存块。这里�ƈ不徏议��用这个函敎ͼ�而是手动的去重新甌��内存�q�拷贝释放�?br />
然后来看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;
            }

�?个用于内存对齐和计算索引�Q�最后一个用于获取一在空闲列表内一个内存块的数量�?br />
然后是refill函数�Q�用于在没有�I�闲内存块时甌��一块大内存�?br />

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链表内，最后组�l��vchunk_list中对应内存卡块的链表�Q�然后重新调整chunk_list列表�Q�最后将甌��到的内存块返回�?br />
最后来看一下调整函数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;
                        }
                    }
                }
            }

�q�里从后臛_��查看对应内存块空闲链表的长度�Q�若��过�q�_��数量�Q�则��其切分�?块较��的内存块放入对应的链表内。这样做的好处是可以形成一个金字塔形的分布状况�Q�既��小的内存块大小拥有的节�Ҏ��量越多，正如本文开头所��_��使用内存池是��Z��解决在申请小块内存时造成的内存碎片�?br />
��x��Q�内存池的讲解已完成�Q�完整的代码请到http://qlanguage.codeplex.com下蝲

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

山寨STL实现之vector

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

首先是vector的定�?br />

template
        class vector
        {
        };

让我们先来看看vector中的一些别�?br />

  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;

�׃��可见�Q�正�?a href="http://www.shnenglu.com/lwch/archive/2012/06/02/177248.html">上一��?/a>所��_��vector的�P代器是由原生的指针来实现的�?br />
下面是其内部的成员变�?br />

  protected:
            typedef vector    self;
            typedef allocator Alloc;

            iterator start;
            iterator finish;
            iterator end_of_element;

start�Q�指向vector的�v始地址
finish�Q�指向最后一个元素的后一个元素的地址
end_of_element�Q�指向已甌��内存块的�l�束位置�Q�finish��L��于或等于end_of_element�Q?br />
在STL中从begin到end��L��以一个前闭后开的�Ş式来表示的，形如[begin,end)�Q�这样做的好处是可以使代码写的更��z�：

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

�q�里��其中的3个成员变量都填充�?�?br /> �?a href="http://www.shnenglu.com/lwch/archive/2012/06/02/177248.html">上一��?/a>所��_��在STL中是��内存分配与对象初始化分开的，同样对象析构与内存释放也是被分开的�?br />
然后是其begin和end�Ҏ��Q�用来获取第一个元素和最后一个元素的后一个元素的�q�代器�?br />

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分别被用来获取第一个元素和最后一个元�?br />

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分别被用来判别容器是否�ؓ�I�、容器内元素的个数和容器的大��?br />

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的头部插入元素会使所有元素后�U�，应此它被设计为单向的�Q�只能由��N��插入或移除数�?br />

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

当然从头部移除数据也�q��不可以，可以使用erase�Ҏ��来移除头部的数据�Q�erase�Ҏ��会在后面的部分作出说明�?br />
我们先来看一下insert_aux�q�个�Ҏ��Q�在插入元素时几乎都使用��C��q�个�Ҏ��?br />

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

在容器还有��够的�I�间�Ӟ��首先��从position位置到finish位置的元素整体后�U�M��个位�|�，最后将要被插入的元素写入到原position的位�|�同时改变finish指针的倹{�?br /> 若空间不��x��Q�首先根据原有空间的大小的一倍来甌��内存�Q�然后将元素从原有位�|�的begin到position拯��到新甌��的内存中�Q�然后在新申请内存的指定位置插入要插入的元素��|��最后将余下的部分也拯��q�来。然后将原有元素析构掉�ƈ把内存释放掉�?br />
��Z��不��?/span>reallocate?
reallocate的本意�ƈ不是在原有内存的位置增加或减��内存，reallocate首先会试囑֜�原有的内存位�|�增加或减少内存�Q?strong>若失败则会重新申请一块新的内存�ƈ把原有的数据拯��q�去�Q�这�U�操作本质上�{��h于重新申请一块内存，应此�q�里使用的是allocate而�ƈ非reallocate�?br />
然后让我们来看一下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;
            }

若是要在最后插入一个元素且容器的剩余空间还��_��的话�Q�直接将元素插入到finish的位�|�，�q�将finish指针后移一位即可。若容器�I�间不够或不是插在最后一个的位置�Q�则调用insert_aux重新分配内存或插入�?br /> 删除旉��先析构掉原有元素�Q�若被删元素不是最后一个元素，则将后面的所有元素拷贝过来，最后将finish指针前移一个位�|��?br />
最后让我们来看一下其中重载的�q�算�W?br />

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内部用的是原生的指针�Q�应此这些运��符的��用方式和原生指针的�ƈ无差异�?strong>值得注意的是在做赋值操作时会��生内存的重新分配与拷贝操作�?br />
��x��Q�vector的讲解已完成�Q�完整的代码请到http://qlanguage.codeplex.com下蝲

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

山寨STL实现之traits,construct&destruct

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

traits技术被�q�泛应用于STL中，通过它您可以��L��的萃取出一个对象的�Ҏ��。在STL中也是通过它来实现性能的最优化�Q�比如一个对象是个POD对象(Plain Old Data)�Q�则在拷贝过�E�中直接可以通过memcpy�{�函数拷贝，而无需调用拯��构造函数或operator=�?br />
先来看看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�c�d��?nbsp;
一、value_type
value_type指示了该�q�代器所保存的值类�?br /> 二、difference_type
difference_type用来指示两个�q�代器之间的距离�c�d��
三、pointer,reference,const_pointer,const_reference
分别是所指之物的指针,引用,指针帔R��和引用常量的�c�d��
四、self
self��q�代器自�w�的�c�d��

下面来看一下iterator_traits�Q�iterator_traits主要用来萃取�q�代器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;
        };

�q�里有一点可以提前预告一下，vector作�ؓ一个容器，其内部是使用指针作�ؓ�q�代器的�Q�那么我们如何萃取出它的值类型等呢？
�{�案很简单，特例化，那么我们��来为iterator_traits分别做两�U�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;
        };

��x��Q�我们可以用iterator_traits萃取出每�U�iterator的值类型等内容了�?br />
之前已经说到了，通过traits可以萃取��Z��些对象的�Ҏ��，从而提高代码的效率。事实确实如此，通过traits可萃取出一个对象是否是一个POD对象�Q�对于一个POD对象�Q�我们在拯��Ӟ��不应该��用其拯��构造函数或是operator=�Q�而用memcpy则效率更高�?br /> 下面我们来看一下__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来表�C�是否存在这个特性�?br />
那么我们如何萃取出基��c�d��诸如int,char�{�的�Ҏ��呢�Q?br /> �{�案依然是特例化�Q�这里代码不再脓出，文末会给出完整代码的详细地址�?br />
最后我们��用一个hash_destruct的函数来获取��个类型是否有析构函数�?br />

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的确很强大，可以通过形参来确定返回值的�c�d��Q�这��h��们就可以萃取��个类型的has_destruct域是__true_type或是__false_type了�?br />
最后来看看construct和destruct的代码，在STL中对象的内存分配和构造是被分开的，对于基础对象int,char�{�，在析构时我们无需调用其析构函数�?br /> 下面来看construct和destruct的实�?br />

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

��x��Q�关于traits技术和construct及destruct的讲解已完成�Q�完整的代码请到http://qlanguage.codeplex.com/下蝲

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

山寨STL实现之allocator

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

作�ؓ一个山寨的STL�Q�那么不得不提的是其中的allocator�Q�空间配�|�器�Q�。顾名思义�Q�它是负责空间分配用的，下面代码十分��单，仅对C函数malloc和free�q�行了薄薄的一层封装，同时�l�定了自定义函数free_handler用于在空间分配时候由于内存被占满了而导致的分配��p�|�?br />
�q�里值得注意的是�Q�这个释攑և�数的函数指针应该是由调用�Ҏ��负责指定�Q��ƈ且它仅有一个参数表明至��需要释攑֤��字节的内存�?br />
下面来看代码�Q�代码非常简单，应此�q�里��׃��逐一展开说明了�?

#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实现�W�记

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

数据�l�构
1. allocator
2. 内存�?/a>
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 发表评论

极品日韩av,亚洲一区二区免费视频,亚洲成人影音

QCore/Library说明文档

前言

内存调试

容器

traits

__type_traits

__container_traits

char_traits

type_compare

�q�代�?

反向�q�代�?

iterator_traits

vector

list

queue和stack

rbtree

set和map

hashtable

hashset和hashmap

basic_string

本章���结

���法

正则

IO

�l�束

修改记录

山寨STL实现之内存池V2

山寨STL实现之list

山寨STL实现之内存池

山寨STL实现之vector

山寨STL实现之traits,construct&destruct

山寨STL实现之allocator

山寨STL实现�W�记

本章��结

��法