侯捷老师——STL源码剖析

合集下载

57、什么是内存池，如何实现

57、什么是内存池，如何实现内存池（Memory Pool）是⼀种内存分配⽅式。

通常我们习惯直接使⽤new、malloc 等申请内存，这样做的缺点在于：由于所申请内存块的⼤⼩不定，当频繁使⽤时会造成⼤量的内存碎⽚并进⽽降低性能。

内存池则是在真正使⽤内存之前，先申请分配⼀定数量的、⼤⼩相等(⼀般情况下)的内存块留作备⽤。

当有新的内存需求时，就从内存池中分出⼀部分内存块，若内存块不够再继续申请新的内存。

这样做的⼀个显著优点是尽量避免了内存碎⽚，使得内存分配效率得到提升。

这⾥简单描述⼀下《STL源码剖析》中的内存池实现机制：allocate包装malloc,deallocate包装free⼀般是⼀次20*2个的申请，先⽤⼀半，留着⼀半，为什么也没个说法，侯捷在STL那边书⾥说好像是 C++委员会成员认为20是个⽐较好的数字，既不⼤也不⼩1. ⾸先客户端会调⽤malloc()配置⼀定数量的区块（固定⼤⼩的内存块，通常为8的倍数），假设40 个32bytes的区块，其中20个区块（⼀半）给程序实际使⽤，1个区块交出，另外19个处于维护状态。

剩余20个（⼀半）留给内存池，此时⼀共有（20*32byte）2. 客户端之后有有内存需求，想申请（20*64bytes）的空间，这时内存池只有（20*32bytes），就先将（10*64bytes)个区块返回，1个区块交出，另外9个处于维护状态，此时内存池空空如也3. 接下来如果客户端还有内存需求，就必须再调⽤malloc()配置空间，此时新申请的区块数量会增加⼀个随着配置次数越来越⼤的附加量，同样⼀半提供程序使⽤，另⼀半留给内存池。

申请内存的时候⽤永远是先看内存池有⽆剩余，有的话就⽤上，然后挂在0-15号某⼀条链表上，要不然就重新申请。

4. 如果整个堆的空间都不够了，就会在原先已经分配区块中寻找能满⾜当前需求的区块数量，能满⾜就返回，不能满⾜就向客户端报bad_alloc异常allocator就是⽤来分配内存的，最重要的两个函数是allocate和deallocate，就是⽤来申请内存和回收内存的，外部（⼀般指容器）调⽤的时候只需要知道这些就够了。

STL源码侯捷注释

STL源码侯捷注释《STL源码侯捷注释》是一本经典的程序员必备书籍，它为广大程序员提供了深入了解STL源码的机会。

本文将从以下几个方面进行分析和评价。

一、作者介绍侯捷是一位著名的程序员和作家，他曾获得多项国际和国内大奖，包括ACM国际程序设计竞赛金牌、IBM杰出软件奖、国家自然科学二等奖等。

他还是多本计算机书籍的作者，如《STL源码剖析》、《C++程序设计》等。

二、书籍概述《STL源码侯捷注释》是一本详细介绍STL源码的书籍，它对STL的各个组成部分进行了详细的解析和注释。

本书的主要特点包括：1.详细的注释：本书对STL源码的每个细节都进行了详细的解释和注释，使读者能够深入了解STL的实现原理。

2.清晰的结构：本书按照STL源码的结构进行组织，并提供了详细的目录和索引，方便读者查找和理解。

3.丰富的例子：本书提供了大量的例子，帮助读者更好地理解STL的使用方法和实现原理。

4.全面的覆盖：本书覆盖了STL的所有组成部分，包括容器、迭代器、算法、仿函数等。

三、书籍优点1.深入浅出：本书的注释和解释非常详细，但又不失深入浅出的风格，使读者能够轻松理解STL的实现原理。

2.丰富的例子：本书提供了大量的例子，使读者能够更好地理解STL的使用方法和实现原理。

3.清晰的结构：本书按照STL源码的结构进行组织，并提供了详细的目录和索引，方便读者查找和理解。

4.全面的覆盖：本书覆盖了STL的所有组成部分，包括容器、迭代器、算法、仿函数等。

四、书籍不足之处1.过于复杂：本书注释和解释的内容非常详细，但有时候可能会让读者感到过于复杂和深入，不太适合初学者。

2.缺少实战案例：本书提供了大量的例子，但是缺少实战案例，读者可能需要自己去实践。

五、适合读者群体《STL源码侯捷注释》适合以下读者群体：1.对STL源码有兴趣的程序员。

2.希望深入了解STL实现原理的程序员。

3.希望提高自己的STL编程能力的程序员。

4.想要更好地掌握C++语言和STL的程序员。

一个游戏程序员学习资料

一个游戏程序员的学习资料1.《数据结构（C语言版）》——严蔚敏、吴伟民清华出版社我觉得其配套习题集甚至比原书更有价值，每个较难的题都值得做一下。

2.《Introduction to Algorithms》第二版中文名《算法导论》关于算法的标准学习教材与工程参考手册，在去年CSDN网站上其翻译版竟然评为年度二十大技术畅销书，同时《程序员》杂志上开设了“算法擂台”栏目，这些溯源固本的举动，不由得使人对中国现今浮躁不堪的所谓“IT”业又产生了一线希望。

这本厚厚的书，幸亏打折我才买得起。

虽然厚达千页，但其英文通俗晓畅，内容深入浅出，可见经典之作往往比一般水准的书还耐读。

还能找到MIT的视频教程，第一节课那个老教授嘻皮笑脸的，后面就是一长发助教上课了。

3.《C语言名题精选百则技巧篇》——冼镜光机械工业出版社作者花费一年时间搜集了各种常见C程序段的极具技巧性的编程法，其内容都是大有来头的，而且给出了详细的参考资料。

如一个普通的Fibonacci数就给出了非递归解、快速算法、扩充算法等，步步深入，直至几无油水可榨。

对于视速度如生命，连一个普通的浮点数转化为整数都另辟蹊径以减少CPU cycle的游戏程序员，怎可不看？4.《计算机算法基础（第二版）》——佘祥宣等华中科大出版社我看到几个学校的研究生拿它作教材（研究生才开算法，太开玩笑了吧）。

这本书薄是薄了点，用作者的话来说，倒也“精辟”。

其实此书是《Fundamentals of Computer Algorithms》的缩写版，不过原书出版太久了，反正我是没找到。

5.《The Art of Computer Programming》Volume 1-3-----------------葵花宝典作者Donald E. Knuth是我心目中与冯.诺依曼、Dijkstra、Shannon并列的四位大师。

这本书作者从读大学本科时开始写，一直写到博士时，十年磨一剑，足见其下足了功夫。

STL常见面试题

STL常见⾯试题
1. 红⿊树的特性与其在C++ STL中的应⽤
map 、set、multiset、multimap的底层实现都是红⿊树，epoll模型的底层数据结构也是红⿊树，linux系统中CFS进程调度算法，也⽤到红⿊树。

红⿊树的特性：
1. 根节点是⿊⾊
2. 不能有两个连续的红节点
3. 空指针是⿊⾊
4. 从任意⼀个结点出发，到后代中空指针的路径上，均包含相同数量的⿊⾊结点。

2. STL内存分配
3. STL map
4.
5. STL 源码中的 hash 表的实现
6. STL 的 unordered_map 和 map 的区别
7. 介绍⼀下 STL 源码的内容。

8. vector分配内存的⽅式
先申请⼀定的⼤⼩的数组, 当数组填满之后,另外申请⼀块原数组两倍⼤的新数组, 然后把原数组的数据拷贝到新数组, 最后释放原数组的⼤⼩。

详情参考《STL源码剖析(侯捷)》。

问STL库，vector的内存管理，deque的内存管理，list的排序
9. STL也问了⼀些问题：⽐如vecotr 和list 的区别，适⽤情况
vector的扩容机制，问到了源码层次。

1. STL中仿函数有什么⽤，和函数指针有什么不同，哪个效率⾼。

面向对象的理论与C++实践清华课程设计

面向对象的理论与C++实践清华课程设计一、课程介绍面向对象的理论与C++实践是清华大学计算机科学与技术系本科生专业选修课程，涵盖面向对象编程理论和C++编程实践两个方面，旨在帮助学生深入理解面向对象思想并用C++语言进行实现。

二、课程内容面向对象编程理论1.面向对象思想概述2.类与对象3.继承、多态与虚函数4.抽象类与纯虚函数5.STL库简介C++编程实践1.C++程序设计基础2.类与对象的实现3.继承、多态与虚函数的实现4.STL库的使用三、课程教材《C++ Primer》（第五版）（中文版），作者：Lippman, Lajoie, Moo，译者：侯捷。

四、课程参考资料1.《Effective C++》（中文版），作者：Scott Meyers，译者：侯杰。

2.《STL源码剖析》（中文版），作者：侯捷。

3.《深入浅出设计模式》（中文版），作者：程杰。

五、课程设计要求1.选题要求：要求选好一个项目，体现应用面向对象编程的思想。

2.设计方案包括：给出所设计类的类体及成员函数原型，试画出相应的类图，写出内部数据结构方案的描述，描述各类或各函数功能作用的注释。

3.程序要求：为了反映面向对象编程语言的特征，要使用C++语言进行编程，采用面向对象思想，必须使用类和对象来体现程序设计思想，要充分利用C++语言的特性和STL库进行程序开发。

六、课程设计流程第一阶段：选题第一次课程上老师将介绍课程设计大概内容，学生需要结合个人实际情况，选定一个初步的设计主题，初步选题可与老师讨论资讯。

相当于开题选题环节。

第二阶段：设计方案在确定题目后，需要自己独立完成课程设计方案。

设计方案要求如上述第五部分所说明。

相当于中期论文。

第三阶段：实现程序在建立好方案后，开始进行程序实现。

实现过程中出现问题，需及时向老师或助教请教解决，最终提交实现代码。

相当于结题报告。

七、课程评分标准1.选题：选题是否合理，是否具有一定难度性；2.设计方案：方案是否完善，方案中的类设计是否具有标准性；3.程序代码：代码是否规范，是否达到良好的代码质量，代码是否具有可扩充性、可移植性等软件工程方面的优良特征；4.报告：书面报告是否符合规范，语言表达、图表使用是否得当；5.程序演示：演示时是否条理清晰，是否表现出更高的带了解问题以及解决问题的能力。

stl的使用介绍的书籍

stl的使用介绍的书籍STL（Standard Template Library，标准模板库）是C++编程语言的一个重要组成部分，它为C++程序员提供了一套丰富的数据结构和算法，极大地提升了开发效率和代码的可重用性。

本文将介绍几本关于STL使用的优秀书籍，帮助读者更好地掌握STL的应用。

1.《Effective STL》《Effective STL》是Scott Meyers写的一本经典著作，旨在向读者展示如何高效地使用STL。

书中通过丰富的示例和详细的讲解，介绍了STL中各个容器、算法和迭代器的使用方法和注意事项。

同时，书中还提供了许多实用的技巧和技巧，帮助读者写出高质量的STL代码。

2.《STL源码剖析》《STL源码剖析》是侯捷教授编著的一本经典教材，深入剖析了STL 的实现原理和内部机制。

这本书不仅讲解了STL中各个容器和算法的实现细节，还介绍了STL的设计思想和优化技巧。

通过阅读本书，读者可以更好地理解STL的底层实现，提升自己的编程能力。

3.《C++标准库》《C++标准库》是Nicolai M. Josuttis撰写的一本权威性书籍，全面介绍了C++标准库，包括STL在内的各个组件。

书中详细讲解了STL中容器、算法、迭代器、函数对象等的使用方法，并给出了大量的示例代码。

此外，书中还介绍了C++11、C++14和C++17中新添加的特性，使读者了解最新的C++标准库开发技术。

4.《STL教程与案例精解》《STL教程与案例精解》是郝斌编著的一本教材，通过大量的案例和实例，系统地讲解了STL的使用方法和应用技巧。

书中从容器、迭代器、算法等方面入手，深入浅出地介绍了STL的各个组成部分，并提供了丰富的练习题和案例分析，帮助读者巩固所学知识。

5.《STL源码剖析与应用》《STL源码剖析与应用》是李师贺编著的一本专门讲解STL源码和应用的书籍。

书中详细解析了STL的设计思想、实现原理和内部机制，帮助读者深入理解STL的底层实现。

侯捷stl源码剖析注释之11 sgi-std-bastring-cc

<std\> 完整列表 The Annotated STL Sources 1G++ 2.91.57，cygnus\cygwin-b20\include\g++\std\ 完整列表// Member templates for the -*- C++ -*- string classes.// Copyright (C) 1994 Free Software Foundation// This file is part of the GNU ANSI C++ Library. This library is free// software; you can redistribute it and/or modify it under the// terms of the GNU General Public License as published by the// Free Software Foundation ; either version 2, or (at your option)// any later version.// This library is distributed in the hope that it will be useful,// but WITHOUT ANY WARRANTY; without even the implied warranty of// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the// GNU General Public License for more details.// You should have received a copy of the GNU General Public License// along with this library; see the file COPYING. If not, write to the Free// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.// As a special exception, if you link this library with files// compiled with a GNU compiler to produce an executable, this does not cause // the resulting executable to be covered by the GNU General Public License. // This exception does not however invalidate any other reasons why// the executable file might be covered by the GNU General Public License.// Written by Jason Merrill based upon the specification by Takanori Adachi // in ANSI X3J16/94-0013R2.extern "C++" {template <class charT, class traits, class Allocator>inline void * basic_string <charT, traits, Allocator>::Rep::operator new (size_t s, size_t extra){return Allocator::allocate(s + extra * sizeof (charT));}template <class charT, class traits, class Allocator>inline void basic_string <charT, traits, Allocator>::Rep::operator delete (void * ptr){Allocator::deallocate(ptr, sizeof(Rep) +reinterpret_cast<Rep *>(ptr)->res *sizeof (charT));}template <class charT, class traits, class Allocator>inline size_t basic_string <charT, traits, Allocator>::Rep::frob_size (size_t s){<std\> 完整列表 The Annotated STL Sources 2 size_t i = 16;while (i < s) i *= 2;return i;}template <class charT, class traits, class Allocator>inline basic_string <charT, traits, Allocator>::Rep *basic_string <charT, traits, Allocator>::Rep::create (size_t extra){extra = frob_size (extra + 1);Rep *p = new (extra) Rep;p->res = extra;p->ref = 1;p->selfish = false;return p;}template <class charT, class traits, class Allocator>charT * basic_string <charT, traits, Allocator>::Rep::clone (){Rep *p = Rep::create (len);p->copy (0, data (), len);p->len = len;return p->data ();}template <class charT, class traits, class Allocator>inline bool basic_string <charT, traits, Allocator>::Rep::excess_slop (size_t s, size_t r){return 2 * (s <= 16 ? 16 : s) < r;}template <class charT, class traits, class Allocator>inline bool basic_string <charT, traits, Allocator>::check_realloc (basic_string::size_type s) const{s += sizeof (charT);rep ()->selfish = false;return (rep ()->ref > 1|| s > capacity ()|| Rep::excess_slop (s, capacity ()));}template <class charT, class traits, class Allocator>void basic_string <charT, traits, Allocator>::alloc (basic_string::size_type size, bool save)<std\> 完整列表 The Annotated STL Sources 3{if (! check_realloc (size))return;Rep *p = Rep::create (size);if (save){p->copy (0, data (), length ());p->len = length ();}elsep->len = 0;repup (p);}template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>&basic_string <charT, traits, Allocator>::replace (size_type pos1, size_type n1,const basic_string& str, size_type pos2, size_type n2){const size_t len2 = str.length ();if (pos1 == 0 && n1 >= length () && pos2 == 0 && n2 >= len2)return operator= (str);OUTOFRANGE (pos2 > len2);if (n2 > len2 - pos2)n2 = len2 - pos2;return replace (pos1, n1, str.data () + pos2, n2);}template <class charT, class traits, class Allocator>inline void basic_string <charT, traits, Allocator>::Rep::copy (size_t pos, const charT *s, size_t n){if (n)traits::copy (data () + pos, s, n);}template <class charT, class traits, class Allocator>inline void basic_string <charT, traits, Allocator>::Rep::move (size_t pos, const charT *s, size_t n){if (n)<std\> 完整列表 The Annotated STL Sources 4 traits::move (data () + pos, s, n);}template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>&basic_string <charT, traits, Allocator>::replace (size_type pos, size_type n1, const charT* s, size_type n2){const size_type len = length ();OUTOFRANGE (pos > len);if (n1 > len - pos)n1 = len - pos;LENGTHERROR (len - n1 > max_size () - n2);size_t newlen = len - n1 + n2;if (check_realloc (newlen)){Rep *p = Rep::create (newlen);p->copy (0, data (), pos);p->copy (pos + n2, data () + pos + n1, len - (pos + n1));p->copy (pos, s, n2);repup (p);}else{rep ()->move (pos + n2, data () + pos + n1, len - (pos + n1));rep ()->copy (pos, s, n2);}rep ()->len = newlen;return *this;}template <class charT, class traits, class Allocator>inline void basic_string <charT, traits, Allocator>::Rep::set (size_t pos, const charT c, size_t n){traits::set (data () + pos, c, n);}template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>:: replace (size_type pos, size_type n1, size_type n2, charT c){const size_t len = length ();OUTOFRANGE (pos > len);if (n1 > len - pos)n1 = len - pos;LENGTHERROR (len - n1 > max_size () - n2);<std\> 完整列表 The Annotated STL Sources 5size_t newlen = len - n1 + n2;if (check_realloc (newlen)){Rep *p = Rep::create (newlen);p->copy (0, data (), pos);p->copy (pos + n2, data () + pos + n1, len - (pos + n1));p->set (pos, c, n2);repup (p);}else{rep ()->move (pos + n2, data () + pos + n1, len - (pos + n1));rep ()->set (pos, c, n2);}rep ()->len = newlen;return *this;}template <class charT, class traits, class Allocator>void basic_string <charT, traits, Allocator>::resize (size_type n, charT c){LENGTHERROR (n > max_size ());if (n > length ())append (n - length (), c);elseerase (n);}template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>::size_typebasic_string <charT, traits, Allocator>::copy (charT* s, size_type n, size_type pos) const{OUTOFRANGE (pos > length ());if (n > length () - pos)n = length () - pos;traits::copy (s, data () + pos, n);return n;}template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>::size_typebasic_string <charT, traits, Allocator>::<std\> 完整列表 The Annotated STL Sources 6 find (const charT* s, size_type pos, size_type n) const{size_t xpos = pos;for (; xpos + n <= length (); ++xpos)if (traits::eq (data () [xpos], *s)&& traits::compare (data () + xpos, s, n) == 0)return xpos;return npos;}template <class charT, class traits, class Allocator>inline basic_string <charT, traits, Allocator>::size_typebasic_string <charT, traits, Allocator>::_find (const charT* ptr, charT c, size_type xpos, size_type len){for (; xpos < len; ++xpos)if (traits::eq (ptr [xpos], c))return xpos;return npos;}template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>::size_typebasic_string <charT, traits, Allocator>::find (charT c, size_type pos) const{return _find (data (), c, pos, length ());}template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>::size_typebasic_string <charT, traits, Allocator>::rfind (const charT* s, size_type pos, size_type n) const{if (n > length ())return npos;size_t xpos = length () - n;if (xpos > pos)xpos = pos;for (++xpos; xpos-- > 0; )if (traits::eq (data () [xpos], *s)&& traits::compare (data () + xpos, s, n) == 0)return xpos;return npos;}template <class charT, class traits, class Allocator><std\> 完整列表 The Annotated STL Sources 7basic_string <charT, traits, Allocator>::size_typebasic_string <charT, traits, Allocator>::rfind (charT c, size_type pos) const{if (1 > length ())return npos;size_t xpos = length () - 1;if (xpos > pos)xpos = pos;for (++xpos; xpos-- > 0; )if (traits::eq (data () [xpos], c))return xpos;return npos;}template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>::size_typebasic_string <charT, traits, Allocator>::find_first_of (const charT* s, size_type pos, size_type n) const{size_t xpos = pos;for (; xpos < length (); ++xpos)if (_find (s, data () [xpos], 0, n) != npos)return xpos;return npos;}template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>::size_typebasic_string <charT, traits, Allocator>::find_last_of (const charT* s, size_type pos, size_type n) const{if (length() == 0)return npos;size_t xpos = length () - 1;if (xpos > pos)xpos = pos;for (++xpos; xpos-- > 0;)if (_find (s, data () [xpos], 0, n) != npos)return xpos;return npos;}template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>::size_typebasic_string <charT, traits, Allocator>::find_first_not_of (const charT* s, size_type pos, size_type n) const<std\> 完整列表 The Annotated STL Sources 8 {size_t xpos = pos;for (; xpos < length (); ++xpos)if (_find (s, data () [xpos], 0, n) == npos)return xpos;return npos;}template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>::size_typebasic_string <charT, traits, Allocator>::find_first_not_of (charT c, size_type pos) const{size_t xpos = pos;for (; xpos < length (); ++xpos)if (traits::ne (data () [xpos], c))return xpos;return npos;}template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>::size_typebasic_string <charT, traits, Allocator>::find_last_not_of (const charT* s, size_type pos, size_type n) const{if (length() == 0)return npos;size_t xpos = length () - 1;if (xpos > pos)xpos = pos;for (++xpos; xpos-- > 0;)if (_find (s, data () [xpos], 0, n) == npos)return xpos;return npos;}template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>::size_typebasic_string <charT, traits, Allocator>::find_last_not_of (charT c, size_type pos) const{if (length() == 0)return npos;size_t xpos = length () - 1;if (xpos > pos)xpos = pos;for (++xpos; xpos-- > 0;)if (traits::ne (data () [xpos], c))return xpos;<std\> 完整列表 The Annotated STL Sources 9return npos;}template <class charT, class traits, class Allocator>int basic_string <charT, traits, Allocator>::compare (const basic_string& str, size_type pos, size_type n) const{OUTOFRANGE (pos > length ());size_t rlen = length () - pos;if (rlen > n)rlen = n;if (rlen > str.length ())rlen = str.length ();int r = traits::compare (data () + pos, str.data (), rlen);if (r != 0)return r;if (rlen == n)return 0;return (length () - pos) - str.length ();}template <class charT, class traits, class Allocator>int basic_string <charT, traits, Allocator>::compare (const charT* s, size_type pos, size_type n) const{OUTOFRANGE (pos > length ());size_t rlen = length () - pos;if (rlen > n)rlen = n;int r = traits::compare (data () + pos, s, rlen);if (r != 0)return r;return (length () - pos) - n;}#include <iostream.h>template <class charT, class traits, class Allocator>istream &operator>> (istream &is, basic_string <charT, traits, Allocator> &s){int w = is.width (0);if (is.ipfx0 ()){register streambuf *sb = is.rdbuf ();s.resize (0);while (1)<std\> 完整列表 The Annotated STL Sources 10 {int ch = sb->sbumpc ();if (ch == EOF){is.setstate (ios::eofbit);break;}else if (traits::is_del (ch)){sb->sungetc ();break;}s += ch;if (--w == 1)break;}}is.isfx ();if (s.length () == 0)is.setstate (ios::failbit);return is;}template <class charT, class traits, class Allocator>ostream &operator<< (ostream &o, const basic_string <charT, traits, Allocator>& s) {return o.write (s.data (), s.length ());}template <class charT, class traits, class Allocator>istream&getline (istream &is, basic_string <charT, traits, Allocator>& s, charT delim) {if (is.ipfx1 ()){_IO_size_t count = 0;streambuf *sb = is.rdbuf ();s.resize (0);while (1){int ch = sb->sbumpc ();if (ch == EOF){is.setstate (count == 0? (ios::failbit|ios::eofbit)<std\> 完整列表 The Annotated STL Sources 11 : ios::eofbit);break;}++count;if (ch == delim)break;s += ch;if (s.length () == s.npos - 1){is.setstate (ios::failbit);break;}}}// We need to be friends with istream to do this.// is._gcount = count;is.isfx ();return is;}// static data member of class basic_string<>template <class charT, class traits, class Allocator>basic_string <charT, traits, Allocator>::Repbasic_string<charT, traits, Allocator>::nilRep = { 0, 0, 1, false };template <class charT, class traits, class Allocator>const basic_string <charT, traits, Allocator>::size_typebasic_string <charT, traits, Allocator>::npos ;} // extern "C++"。

侯捷stl源码剖析注释45 sgi-stl-tree

The Annotated STL Sources
<stl_tree.h> 完整列表
3
base_ptr node; // 它用來與容器之間產生一個連結關係（make a reference）
// 以下其實可實作於 operator++ 內，因為再無他處會呼叫此函式了。
void increment()
base_ptr y = node->parent;
// 狀況(3) 找出父節點
while (node == y->left) {
// 當現行節點身為左子節點
node = y;
// 一直交替往上走，直到現行節點
y = y->parent;
// 不為左子節點
}
node = y;
// 此時之父節點即為答案
狀況3找出父節點當現行節點身為左子節點一直交替往上走直到現行節點不為左子節點此時之父節點即為答案lt
<stl_tree.h> 完整列表
1
G++ 2.91.57，cygnus\cygwin-b20\include\g++\stl_tree.h 完整列表 /* * * Copyright (c) 1996,1997 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. * * * Copyright (c) 1994 * Hewlett-Packard Company * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Hewlett-Packard Company makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. * * */

vector源码1（参考STL源码--侯捷）：源码

vector源码1（参考STL源码--侯捷）：源码vector源码1(参考STL源码--侯捷)vector概述Vector是动态空间，随着元素的加⼊，它的内部机制会⾃⾏扩充空间纳⼊新元素，vector的使⽤效率，关键在于其对⼤⼩的控制以及重新配置时的元素迁移效率。

Vector定义摘要template<class T,class Alloc=alloc>//alloc是SGI STL的空间配置器class vector{public:typedef T value_type;typedef value_type*pointer;typedef value_type*iterator;typedef value_type&reference;typedef size_t size_type;typedef ptrdiff_t difference_type;protected:typedef simple_alloc<value_type,Alloc>data_allocator;//simple_alloc是SGI STL的空间配置器iterator start;//表⽰⽬前使⽤空间的头iterator finish;//表⽰⽬前使⽤空间的尾iterator end_of_storage;//表⽰⽬前可⽤空间的尾void insert_aux(iterator position,const T&x);//插⼊元素，保护类型，对象不可调⽤void deallocate(){if(start)/*为vector再分配空间为其原始可容纳空间的⼀倍,deallocate()函数如下：*static void deallocate(T *p,size_t n){if(0!=n) Alloc::deallocate(p,n*sizeof(T));}*/data_allocator::deallocate(start,end_of_storage-start);}void fill_initialize(size_type n,const T&value){//⽤于vector初始赋值start=allocate_and_fill(n,value);finish=start+n;end_of_storage=finish;}public:iterator begin(){return start;}//头指针iterator end(){return finish;}//尾指针size_type size()const{return size_type(end()-begin());}//存储元素数量size_type capacity()const{return size_type(end_of_storage-begin());}//当前可容纳元素bool empty()const{return begin()==end();}//是否为空reference operator[](size_type n){return*(begin()+n);}//定位元素，返回第n+1个元素vector():start(0),finish(0),end_of_storage(0){}//初始化，如：vector<int> v;/*size_type是STL类中定义的类型属性，⽤以保存任意string和vector类对象的长度,以下都为初始化vector,如：vector<int> v(10,1)*/vector(size_type n,const T&value){fill_initialize(n,value);}vector(int n,const T&value){fill_initialize(n,value);}vector(long n,const T&value){fill_initialize(n,value);}//explit 防⽌隐式转换，此时初始化如：vector<int> v(10)；explicit vector(size_type n){fill_initialize(n,T());}~vector(){/*全局函数,destory（）有两个版本，第⼀个版本接收⼀个指针，准备将该指针指向的对象析构掉；第⼆个版本就是接收first和last两个迭代器（如下），将[first，last]下的对象析构掉。

侯捷stl源码剖析注释之17 sgi-stl-33-function

SGI STL 3.3 <stl_iterator.h> 完整列表 The Annotated STL Sources 1SGI STL 3.3 stl_function.h 完整列表/*** Copyright (c) 1994* Hewlett-Packard Company** Permission to use, copy, modify, distribute and sell this software* and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and* that both that copyright notice and this permission notice appear* in supporting documentation. Hewlett-Packard Company makes no* representations about the suitability of this software for any* purpose. It is provided "as is" without express or implied warranty. *** Copyright (c) 1996-1998* Silicon Graphics Computer Systems, Inc.** Permission to use, copy, modify, distribute and sell this software* and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and* that both that copyright notice and this permission notice appear* in supporting documentation. Silicon Graphics makes no* representations about the suitability of this software for any* purpose. It is provided "as is" without express or implied warranty. *//* NOTE: This is an internal header file, included by other STL headers. * You should not attempt to use it directly.*/#ifndef __SGI_STL_INTERNAL_FUNCTION_H#define __SGI_STL_INTERNAL_FUNCTION_H__STL_BEGIN_NAMESPACEtemplate <class _Arg, class _Result>struct unary_function {typedef _Arg argument_type;typedef _Result result_type;};template <class _Arg1, class _Arg2, class _Result>struct binary_function {typedef _Arg1 first_argument_type;typedef _Arg2 second_argument_type;typedef _Result result_type;};第1章 Classes 的語法和語意The Annotated STL Sources 2 template <class _Tp>struct plus : public binary_function<_Tp,_Tp,_Tp> {_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; } };template <class _Tp>struct minus : public binary_function<_Tp,_Tp,_Tp> {_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; } };template <class _Tp>struct multiplies : public binary_function<_Tp,_Tp,_Tp> {_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; } };template <class _Tp>struct divides : public binary_function<_Tp,_Tp,_Tp> {_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; } };// identity_element (not part of the C++ standard).template <class _Tp> inline _Tp identity_element(plus<_Tp>) {return _Tp(0);}template <class _Tp> inline _Tp identity_element(multiplies<_Tp>) {return _Tp(1);}template <class _Tp>struct modulus : public binary_function<_Tp,_Tp,_Tp>{_Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; } };template <class _Tp>struct negate : public unary_function<_Tp,_Tp>{_Tp operator()(const _Tp& __x) const { return -__x; }};template <class _Tp>struct equal_to : public binary_function<_Tp,_Tp,bool>{bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; } };template <class _Tp>struct not_equal_to : public binary_function<_Tp,_Tp,bool>SGI STL 3.3 <stl_iterator.h> 完整列表 The Annotated STL Sources 3{bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; } };template <class _Tp>struct greater : public binary_function<_Tp,_Tp,bool>{bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; } };template <class _Tp>struct less : public binary_function<_Tp,_Tp,bool>{bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; } };template <class _Tp>struct greater_equal : public binary_function<_Tp,_Tp,bool>{bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; } };template <class _Tp>struct less_equal : public binary_function<_Tp,_Tp,bool>{bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; } };template <class _Tp>struct logical_and : public binary_function<_Tp,_Tp,bool>{bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; } };template <class _Tp>struct logical_or : public binary_function<_Tp,_Tp,bool>{bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; } };template <class _Tp>struct logical_not : public unary_function<_Tp,bool>{bool operator()(const _Tp& __x) const { return !__x; }};template <class _Predicate>class unary_negate: public unary_function<typename _Predicate::argument_type, bool> {第1章 Classes 的語法和語意The Annotated STL Sources 4 protected:_Predicate _M_pred;public:explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}bool operator()(const typename _Predicate::argument_type& __x) const { return !_M_pred(__x);}};template <class _Predicate>inline unary_negate<_Predicate>not1(const _Predicate& __pred){return unary_negate<_Predicate>(__pred);}template <class _Predicate>class binary_negate: public binary_function<typename _Predicate::first_argument_type,typename _Predicate::second_argument_type,bool> {protected:_Predicate _M_pred;public:explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {}bool operator()(const typename _Predicate::first_argument_type& __x, const typename _Predicate::second_argument_type& __y) const {return !_M_pred(__x, __y);}};template <class _Predicate>inline binary_negate<_Predicate>not2(const _Predicate& __pred){return binary_negate<_Predicate>(__pred);}template <class _Operation>class binder1st: public unary_function<typename _Operation::second_argument_type,typename _Operation::result_type> {protected:_Operation op;typename _Operation::first_argument_type value;public:binder1st(const _Operation& __x,const typename _Operation::first_argument_type& __y)SGI STL 3.3 <stl_iterator.h> 完整列表 The Annotated STL Sources 5: op(__x), value(__y) {}typename _Operation::result_typeoperator()(const typename _Operation::second_argument_type& __x) const { return op(value, __x);}};template <class _Operation, class _Tp>inline binder1st<_Operation>bind1st(const _Operation& __fn, const _Tp& __x){typedef typename _Operation::first_argument_type _Arg1_type;return binder1st<_Operation>(__fn, _Arg1_type(__x));}template <class _Operation>class binder2nd: public unary_function<typename _Operation::first_argument_type,typename _Operation::result_type> {protected:_Operation op;typename _Operation::second_argument_type value;public:binder2nd(const _Operation& __x,const typename _Operation::second_argument_type& __y): op(__x), value(__y) {}typename _Operation::result_typeoperator()(const typename _Operation::first_argument_type& __x) const { return op(__x, value);}};template <class _Operation, class _Tp>inline binder2nd<_Operation>bind2nd(const _Operation& __fn, const _Tp& __x){typedef typename _Operation::second_argument_type _Arg2_type;return binder2nd<_Operation>(__fn, _Arg2_type(__x));}// unary_compose and binary_compose (extensions, not part of the standard).template <class _Operation1, class _Operation2>class unary_compose: public unary_function<typename _Operation2::argument_type,typename _Operation1::result_type>{protected:_Operation1 _M_fn1;第1章 Classes 的語法和語意The Annotated STL Sources 6 _Operation2 _M_fn2;public:unary_compose(const _Operation1& __x, const _Operation2& __y): _M_fn1(__x), _M_fn2(__y) {}typename _Operation1::result_typeoperator()(const typename _Operation2::argument_type& __x) const {return _M_fn1(_M_fn2(__x));}};template <class _Operation1, class _Operation2>inline unary_compose<_Operation1,_Operation2>compose1(const _Operation1& __fn1, const _Operation2& __fn2){return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);}template <class _Operation1, class _Operation2, class _Operation3>class binary_compose: public unary_function<typename _Operation2::argument_type,typename _Operation1::result_type> {protected:_Operation1 _M_fn1;_Operation2 _M_fn2;_Operation3 _M_fn3;public:binary_compose(const _Operation1& __x, const _Operation2& __y,const _Operation3& __z): _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }typename _Operation1::result_typeoperator()(const typename _Operation2::argument_type& __x) const {return _M_fn1(_M_fn2(__x), _M_fn3(__x));}};template <class _Operation1, class _Operation2, class _Operation3>inline binary_compose<_Operation1, _Operation2, _Operation3>compose2(const _Operation1& __fn1, const _Operation2& __fn2,const _Operation3& __fn3){return binary_compose<_Operation1,_Operation2,_Operation3>(__fn1, __fn2, __fn3);}template <class _Arg, class _Result>class pointer_to_unary_function : public unary_function<_Arg, _Result> { protected:_Result (*_M_ptr)(_Arg);public:SGI STL 3.3 <stl_iterator.h> 完整列表 The Annotated STL Sources 7pointer_to_unary_function() {}explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {} _Result operator()(_Arg __x) const { return _M_ptr(__x); }};template <class _Arg, class _Result>inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg)) {return pointer_to_unary_function<_Arg, _Result>(__x);}template <class _Arg1, class _Arg2, class _Result>class pointer_to_binary_function :public binary_function<_Arg1,_Arg2,_Result> {protected:_Result (*_M_ptr)(_Arg1, _Arg2);public:pointer_to_binary_function() {}explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)): _M_ptr(__x) {}_Result operator()(_Arg1 __x, _Arg2 __y) const {return _M_ptr(__x, __y);}};template <class _Arg1, class _Arg2, class _Result>inline pointer_to_binary_function<_Arg1,_Arg2,_Result>ptr_fun(_Result (*__x)(_Arg1, _Arg2)) {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__x);}// identity is an extensions: it is not part of the standard.template <class _Tp>struct _Identity : public unary_function<_Tp,_Tp> {const _Tp& operator()(const _Tp& __x) const { return __x; }};template <class _Tp> struct identity : public _Identity<_Tp> {};// select1st and select2nd are extensions: they are not part of the standard. template <class _Pair>struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> { const typename _Pair::first_type& operator()(const _Pair& __x) const { return __x.first;}};template <class _Pair>struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type>第1章 Classes 的語法和語意The Annotated STL Sources 8 {const typename _Pair::second_type& operator()(const _Pair& __x) const { return __x.second;}};template <class _Pair> struct select1st : public _Select1st<_Pair> {}; template <class _Pair> struct select2nd : public _Select2nd<_Pair> {};// project1st and project2nd are extensions: they are not part of the standard template <class _Arg1, class _Arg2>struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {_Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; } };template <class _Arg1, class _Arg2>struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {_Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; } };template <class _Arg1, class _Arg2>struct project1st : public _Project1st<_Arg1, _Arg2> {};template <class _Arg1, class _Arg2>struct project2nd : public _Project2nd<_Arg1, _Arg2> {};// constant_void_fun, constant_unary_fun, and constant_binary_fun are // extensions: they are not part of the standard. (The same, of course, // is true of the helper functions constant0, constant1, and constant2.)template <class _Result>struct _Constant_void_fun {typedef _Result result_type;result_type _M_val;_Constant_void_fun(const result_type& __v) : _M_val(__v) {}const result_type& operator()() const { return _M_val; }};template <class _Result, class _Argument>struct _Constant_unary_fun {typedef _Argument argument_type;typedef _Result result_type;result_type _M_val;_Constant_unary_fun(const result_type& __v) : _M_val(__v) {}const result_type& operator()(const _Argument&) const { return _M_val; } };SGI STL 3.3 <stl_iterator.h> 完整列表 The Annotated STL Sources 9template <class _Result, class _Arg1, class _Arg2>struct _Constant_binary_fun {typedef _Arg1 first_argument_type;typedef _Arg2 second_argument_type;typedef _Result result_type;_Result _M_val;_Constant_binary_fun(const _Result& __v) : _M_val(__v) {}const result_type& operator()(const _Arg1&, const _Arg2&) const {return _M_val;}};template <class _Result>struct constant_void_fun : public _Constant_void_fun<_Result> {constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {} };template <class _Result,class _Argument __STL_DEPENDENT_DEFAULT_TMPL(_Result)>struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument> {constant_unary_fun(const _Result& __v): _Constant_unary_fun<_Result, _Argument>(__v) {}};template <class _Result,class _Arg1 __STL_DEPENDENT_DEFAULT_TMPL(_Result),class _Arg2 __STL_DEPENDENT_DEFAULT_TMPL(_Arg1)>struct constant_binary_fun: public _Constant_binary_fun<_Result, _Arg1, _Arg2>{constant_binary_fun(const _Result& __v): _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}};template <class _Result>inline constant_void_fun<_Result> constant0(const _Result& __val){return constant_void_fun<_Result>(__val);}template <class _Result>inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val) {return constant_unary_fun<_Result,_Result>(__val);}第1章 Classes 的語法和語意 The Annotated STL Sources 10template <class _Result>inline constant_binary_fun<_Result,_Result,_Result>constant2(const _Result& __val){return constant_binary_fun<_Result,_Result,_Result>(__val);}// subtractive_rng is an extension: it is not part of the standard. // Note: this code assumes that int is 32 bits.class subtractive_rng : public unary_function<unsigned int, unsigned int> { private:unsigned int _M_table[55];size_t _M_index1;size_t _M_index2;public:unsigned int operator()(unsigned int __limit) {_M_index1 = (_M_index1 + 1) % 55;_M_index2 = (_M_index2 + 1) % 55;_M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2]; return _M_table[_M_index1] % __limit;}void _M_initialize(unsigned int __seed){unsigned int __k = 1;_M_table[54] = __seed;size_t __i;for (__i = 0; __i < 54; __i++) {size_t __ii = (21 * (__i + 1) % 55) - 1;_M_table[__ii] = __k;__k = __seed - __k;__seed = _M_table[__ii];}for (int __loop = 0; __loop < 4; __loop++) {for (__i = 0; __i < 55; __i++)_M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55]; }_M_index1 = 0;_M_index2 = 31;}subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }subtractive_rng() { _M_initialize(161803398u); }};// Adaptor function objects: pointers to member functions.SGI STL 3.3 <stl_iterator.h> 完整列表 The Annotated STL Sources 11// There are a total of 16 = 2^4 function objects in this family.// (1) Member functions taking no arguments vs member functions taking // one argument.// (2) Call through pointer vs call through reference.// (3) Member function with void return type vs member function with// non-void return type.// (4) Const vs non-const member function.// Note that choice (3) is nothing more than a workaround: according// to the draft, compilers should handle void and non-void the same way. // This feature is not yet widely implemented, though. You can only use // member functions returning void if your compiler supports partial// specialization.// All of this complexity is in the function objects themselves. You can // ignore it by using the helper function mem_fun and mem_fun_ref,// which create whichever type of adaptor is appropriate.// (mem_fun1 and mem_fun1_ref are no longer part of the C++ standard,// but they are provided for backward compatibility.)template <class _Ret, class _Tp>class mem_fun_t : public unary_function<_Tp*,_Ret> {public:explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}_Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }private:_Ret (_Tp::*_M_f)();};template <class _Ret, class _Tp>class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {public:explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}_Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }private:_Ret (_Tp::*_M_f)() const;};template <class _Ret, class _Tp>class mem_fun_ref_t : public unary_function<_Tp,_Ret> {public:explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}_Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }private:_Ret (_Tp::*_M_f)();};第1章 Classes 的語法和語意The Annotated STL Sources 12 template <class _Ret, class _Tp>class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {public:explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {} _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }private:_Ret (_Tp::*_M_f)() const;};template <class _Ret, class _Tp, class _Arg>class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {public:explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}_Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); } private:_Ret (_Tp::*_M_f)(_Arg);};template <class _Ret, class _Tp, class _Arg>class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> { public:explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {} _Ret operator()(const _Tp* __p, _Arg __x) const{ return (__p->*_M_f)(__x); }private:_Ret (_Tp::*_M_f)(_Arg) const;};template <class _Ret, class _Tp, class _Arg>class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {public:explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}_Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); } private:_Ret (_Tp::*_M_f)(_Arg);};template <class _Ret, class _Tp, class _Arg>class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {public:explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {} _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); } private:_Ret (_Tp::*_M_f)(_Arg) const;};#ifdef __STL_CLASS_PARTIAL_SPECIALIZATIONtemplate <class _Tp>SGI STL 3.3 <stl_iterator.h> 完整列表 The Annotated STL Sources 13class mem_fun_t<void, _Tp> : public unary_function<_Tp*,void> {public:explicit mem_fun_t(void (_Tp::*__pf)()) : _M_f(__pf) {}void operator()(_Tp* __p) const { (__p->*_M_f)(); }private:void (_Tp::*_M_f)();};template <class _Tp>class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*,void> { public:explicit const_mem_fun_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}void operator()(const _Tp* __p) const { (__p->*_M_f)(); }private:void (_Tp::*_M_f)() const;};template <class _Tp>class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {public:explicit mem_fun_ref_t(void (_Tp::*__pf)()) : _M_f(__pf) {}void operator()(_Tp& __r) const { (__r.*_M_f)(); }private:void (_Tp::*_M_f)();};template <class _Tp>class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> { public:explicit const_mem_fun_ref_t(void (_Tp::*__pf)() const) : _M_f(__pf) {} void operator()(const _Tp& __r) const { (__r.*_M_f)(); }private:void (_Tp::*_M_f)() const;};template <class _Tp, class _Arg>class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*,_Arg,void> { public:explicit mem_fun1_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }private:void (_Tp::*_M_f)(_Arg);};template <class _Tp, class _Arg>class const_mem_fun1_t<void, _Tp, _Arg>: public binary_function<const _Tp*,_Arg,void> {public:explicit const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}第1章 Classes 的語法和語意The Annotated STL Sources 14 void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); } private:void (_Tp::*_M_f)(_Arg) const;};template <class _Tp, class _Arg>class mem_fun1_ref_t<void, _Tp, _Arg>: public binary_function<_Tp,_Arg,void> {public:explicit mem_fun1_ref_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }private:void (_Tp::*_M_f)(_Arg);};template <class _Tp, class _Arg>class const_mem_fun1_ref_t<void, _Tp, _Arg>: public binary_function<_Tp,_Arg,void> {public:explicit const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {} void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); } private:void (_Tp::*_M_f)(_Arg) const;};#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */// Mem_fun adaptor helper functions. There are only two:// mem_fun and mem_fun_ref. (mem_fun1 and mem_fun1_ref// are provided for backward compatibility, but they are no longer// part of the C++ standard.)template <class _Ret, class _Tp>inline mem_fun_t<_Ret,_Tp> mem_fun (_Ret (_Tp::*__f)()){ return mem_fun_t<_Ret,_Tp>(__f); }template <class _Ret, class _Tp>inline const_mem_fun_t<_Ret,_Tp> mem_fun (_Ret (_Tp::*__f)() const){ return const_mem_fun_t<_Ret,_Tp>(__f); }template <class _Ret, class _Tp>inline mem_fun_ref_t<_Ret,_Tp> mem_fun_ref (_Ret (_Tp::*__f)()){ return mem_fun_ref_t<_Ret,_Tp>(__f); }template <class _Ret, class _Tp>inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref (_Ret (_Tp::*__f)() const) { return const_mem_fun_ref_t<_Ret,_Tp>(__f); }template <class _Ret, class _Tp, class _Arg>SGI STL 3.3 <stl_iterator.h> 完整列表 The Annotated STL Sources 15inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun (_Ret (_Tp::*__f)(_Arg)){ return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }template <class _Ret, class _Tp, class _Arg>inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun (_Ret (_Tp::*__f)(_Arg) const) { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }template <class _Ret, class _Tp, class _Arg>inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun_ref (_Ret (_Tp::*__f)(_Arg)) { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }template <class _Ret, class _Tp, class _Arg>inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>mem_fun_ref (_Ret (_Tp::*__f)(_Arg) const){ return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }template <class _Ret, class _Tp, class _Arg>inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg)){ return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }template <class _Ret, class _Tp, class _Arg>inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const) { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }template <class _Ret, class _Tp, class _Arg>inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg)) { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }template <class _Ret, class _Tp, class _Arg>inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const){ return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }__STL_END_NAMESPACE#endif /* __SGI_STL_INTERNAL_FUNCTION_H */// Local Variables:// mode:C++// End:。

分享一些学习资料-大量PDF电子书

分享⼀些学习资料-⼤量PDF电⼦书分享⼀些学习⽤的电⼦书籍，给那些喜欢看书⽽不⼀定有机会买书的童鞋。

反对积分下载，提倡⾃由分享。

提取密码: np33主要包括⼏个部分的东西：1. C/C++/数据结构、算法类的，也会有⼀些计算机基础的，如《深⼊理解计算机系统》2. PHP书籍及周边。

如Apache，Nginx, mysql, HTTP，前端等。

3. Linux开发及内核相关。

4. ⾮技术类书籍。

技术之外，还是要有⽣活滴。

各书⽬明细如下：⼀、C/C++/数据结构与算法系列1. 《编程珠玑2》中⽂版及英⽂原版2. 《数据结构与算法分析 C++描述》3. 侯捷的《STL源码剖析》和《泛型编程与STL》（侯捷译）4. 程序员锻炼三部曲（单元测试之道、版本控制之道、项⽬⾃动化之道）5. 《深⼊理解计算机系统》6. 《⾼效能⼈⼠的七个习惯》7. 《计算机程序设计艺术》卷1和卷28. 《代码⼤全（第⼆版）》9. 《代码之美》中⽂版10. 《c++沉思录》11. 《c缺陷与陷阱》12. 《c语⾔⼊门经典》13. 《数据结构-c语⾔版》严蔚敏14. 《数据结构与算法分析-c描述》15. 《21天学通c语⾔》16. ⼀些c语⾔⾯试题⽬17. 《C++ Primer》18. 《C++编程艺术》19. 《c和指针》⼆、PHP书籍及周边⽂件夹中有个【前辈分享的php书籍】，包含了不少书籍。

这⾥仅列出不包含在这个⽂件夹中的：1. 《由浅⼊深探究mysql索引结构原理、性能分析与优化》，⼀个博友写的博客，可以看看2. 《深⼊理解PHP内核》不是官⽅出的，⾥边应该有些错误。

看看就⾏3. 《PHP DEBUG Manual Public》 php调试的书籍4. 《git指南》和《pro Git》 Git版本控制⼯具的书籍5. 《TCP/IP详解》3卷。

貌似应该放到⼀个单独的⽬录<⽹络编程>中，有时间再打理吧6. 《PHP5权威编程》7. 《PHP design pattern》设计模式的书8. 《Learning PHP、Mysql、JavaScript》基础书籍9. 《精通正则表达式》学习正则表达式的经典著作10. 《HTTP权威指南》的确很权威11. 《PHP应⽤性能最优化实践》12. 《⼤数据时代》待整理。

vector源码2（参考STL源码--侯捷）：空间分配、push_back

vector源码2（参考STL源码--侯捷）：空间分配、push_backvector源码2(参考STL源码--侯捷)vector的构造和内存管理 vector所采⽤的数据结构⾮常简单：线性连续空间，它是由两个迭代器start和finish分别指向配置得来的连续空间中⽬前已被使⽤的范围，并以迭代器end_of_storage指向整块连续空间(含备⽤空间)的尾端：class vector {..........protected:typedef simple_alloc<value_type,Alloc> data_allocator; //simple_alloc是SGI STL的空间配置器iterator start; //表⽰⽬前使⽤空间的头iterator finish; //表⽰⽬前使⽤空间的尾iterator end_of_storage; //表⽰⽬前可⽤空间的尾.......... 为了降低空间速配成本，vector的实际配置⼤⼩是原来容器⼤⼩的2倍，见下图：#include<bits/stdc++.h>using namespace std;int main(){vector<int> v(3,3);cout<<v.size()<<""<<v.capacity()<<endl; //3 3v.push_back(5);cout<<v.size()<<""<<v.capacity()<<endl; //4 6v.push_back(6);v.push_back(7);v.push_back(8);cout<<v.size()<<""<<v.capacity()<<endl; //7 12for(int i=0;i<v.size();i++){ //3 3 3 5 6 7 8cout<<v[i]<<'';}cout<<endl;v.pop_back();v.pop_back();cout<<v.size()<<""<<v.capacity()<<endl; //5 12v.pop_back();cout<<v.size()<<""<<v.capacity()<<endl; //4 12vector<int>::iterator it=find(v.begin(),v.end(),5);if(it!=v.end())v.erase(it);cout<<v.size()<<""<<v.capacity()<<endl; //3 12it=find(v.begin(),v.end(),3);if(it!=v.end())v.insert(it,4,7);cout<<v.size()<<""<<v.capacity()<<endl; //7 12for(int i=0;i<v.size();i++){ //7 7 7 7 3 3 3cout<<v[i]<<'';}cout<<endl;v.clear();cout<<v.size()<<""<<v.capacity()<<endl; //0 12return0;} vector缺省使⽤alloc作为空间配置器，并据此另外定义了⼀个data_allocator，为的是更⽅便以元素⼤⼩为配置单位，data_allocator::deallocate(n)表⽰配置n个元素空间，vector提供许多constructors⼀个允许我们指定空间⼤⼩及初值。

408考试大纲参考书

408考试大纲参考书
408考试是指计算机等级考试（Computer Rank Examination）的高级程序员考试，包括必考科目和选择科目。

以下是408考试大纲的参考书籍：
必考科目参考书：
1. 《C++ Primer》（第五版）- Stanley B. Lippman, Josée Lajoie, Barbara E. Moo
2. 《Effective C++》（第三版）- Scott Meyers
3. 《STL源码剖析》- 侯捷
4. 《UNIX环境高级编程》- 万晓东
选择科目参考书：
1. 《TCP/IP详解卷1：协议》- W. Richard Stevens
2. 《Java核心技术卷一：基础知识》（第十版）- Cay S. Horstmann, Gary Cornell
3. 《数据库系统原理》（第五版）- Abraham Silberschatz, Henry F. Korth, S. Sudarshan
4. 《计算机操作系统》（第三版）- Andrew S. Tanenbaum, Herbert Bos
5. 《算法导论》- Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein
以上书籍为参考书籍，依据408考试大纲进行学习和备考是最有效的方法。

另外，根据自身情况和实际需求，建议选择对应科目的标准教材进行深入学习，以便更好地掌握知识和技能。

侯捷STL课程及源码剖析学习1

侯捷STL课程及源码剖析学习11.C++标准库和STL C++标准库以header files形式呈现：1. C++标准库的header files不带后缀名（.h），例如#include <vector>2. 新式C header files 不带后缀名.h，例如#include<cstdio>3. 旧式C header files （带有后缀名.h）仍然可⽤，例如#include <stdio.h>4. 新式headers内的组件封装于namespace “std”。

using namespace std；或者以 using std::cout;的形式5. 旧式headers 内的组件不封装于namespace "std" 在标准库中，标准模板库STL（Standard Template Library），占据了标准库70%，80%以上的内容。

C++ 标准库的范围⼤于STL的范围。

STL的核⼼思想是泛型编程（Generic Programming）。

重要资源：⽹站：书籍：The C++ standard Library second edition；STL 源码剖析2.STL 六⼤组件STL分为六⼤组件：容器(container)：常⽤数据结构，⼤致分为两类，序列容器，如vector，list，deque，关联容器，如set，map。

在实现上，是类模板(class template)迭代器(iterator)：⼀套访问容器的接⼝，⾏为类似于指针。

它为不同算法提供的相对统⼀的容器访问⽅式，使得设计算法时⽆需关注过多关注数据。

（“算法”指⼴义的算法，操作数据的逻辑代码都可认为是算法）算法(algorithm)：提供⼀套常⽤的算法，如sort，search，copy，erase … 在实现上，可以认为是⼀种函数模板(function template)。

C++traits技术浅谈

C++traits技术浅谈前⾔ traits，⼜被叫做特性萃取技术，说得简单点就是提取“被传进的对象”对应的返回类型，让同⼀个接⼝实现对应的功能。

因为STL的算法和容器是分离的，两者通过迭代器链接。

算法的实现并不知道⾃⼰被传进来什么。

萃取器相当于在接⼝和实现之间加⼀层封装，来隐藏⼀些细节并协助调⽤合适的⽅法，这需要⼀些技巧（例如，偏特化）。

最后附带⼀个⼩⼩的例⼦，应该能更好地理解特性萃取。

下⾯⼤部分来源于《STL源码剖析》，看原书能了解更多细节。

Traits编程技法让我们⼀点点抛出问题，然后⼀点点深⼊。

1. ⾸先，在算法中运⽤迭代器时，很可能会⽤到其相应型别（迭代器所指之物的型别）。

假设算法中有必要声明⼀个变量，以“迭代器所指对象的型别”为型别，该怎么办呢？解决⽅法是：利⽤function template的参数推导机制。

1 template <class I, class T>2void func_impl(I iter, T t) {3 T tmp; // 这⾥就是迭代器所指物的类型新建的对象4// ... 功能实现5 }67 template <class I>8 inline9void func(I iter) {10 func_impl(iter, *iter); // 传⼊iter和iter所指的值，class⾃动推导11 }1213int main() {14int i;15 func(&i);16 } 这⾥已经可以看出封装的意思了，没有⼀层impl的封装的话，每次你都要显式地说明迭代器指向对象型别，才能新建tmp变量。

加⼀层封装显得清爽很多。

迭代器相应型别不只是“迭代器所指对象的型别”⼀种⽽已。

根据经验，最常⽤的相应型别有五种，然⽽并⾮任何情况下任何⼀种都可以利⽤上述的template参数推导机制来取得。

函数的“template参数推导机制”推导的只是参数，⽆法推导函数的返回值类型。

侯捷-C++ 内存管理与优化高级培训

培训纲要
第 1 阶段：CRT (C Runtime) malloc 深度剖析讓學員充份了解 Microsoft C++ 對 malloc 的作法（非常複雜精巧）；除學習其中技術，也足以評估自行加上各種 allocators 是必要還是多餘。第 2 阶段：C++内存管理相关操作深入剖析，应用开发技巧、实践与模式 new expression vs. operator new delete expression vs. operator delete array new and array delete placement new about overhead examples for operator new/delete overloading 第 3 阶段： STL 程序库内存管理设施深入剖析，应用开发技巧、实践与模式 std::auto_ptr boost::shared_ptr How to inherit operator new/delete Introduction to std::allocator
第 3 页共 3 页
培训简介
Memory management 一向是 C++ programmer 的痛点，主要因为 C++ 不提供 Garbage Collection。这是效能顾虑下的一种取舍。现实如此，我们必须追求在如此的现实下如何又快又好地运用 memory，使符合速度和空间的最大利益。本课程在低阶上全面介绍 C++ 提供的各种 memory 管理工具（各种 overloadable operators），在高阶上深刻学习各大链接库（包括 STL, Loki, MFC, Boost）的 Pooled Allocation 的作法，并提供它们的高度可移植版（侯捷改编），同时提供各种效率优化技巧实践、与模式。

vector源码3（参考STL源码--侯捷）：pop_back、erase、clear、i。。。

vector源码3（参考STL源码--侯捷）：pop_back、erase、clear、i。

vector源码3(参考STL源码--侯捷):pop_back、erase、clear、insertpop_back//删除尾部元素，调整⼤⼩void pop_back(){--finish; //尾端标记往前⼀格，表⽰放弃尾部元素destroy(finish);}erase//清除(first,last)中的所有元素iterator erase(iterator first,iterator last){iterator i=copy(last,finish,first);//将last到finish的元素往前复制，从first位置开始destory(i,finish);finish=finish-(last-first);return first;}//清除某个位置上的元素iterator erase(iterator position){if(position+1!=end()){copy(position+1,finish,position);}--finish;destory(finish);return position;}clearvoid clear(){erase(begin(),end());}inserttemplate <class T,class Alloc>void vector<T,Alloc>::insert(iterator position,size_type n,const T& x){if(n!=0){if(size_type(end_of_storage-finish)>=n){//备⽤空间⼤于等于"新增元素"T x_copy=x;//以下计算插⼊点之后的现有元素个数const size_type elems_after=finish-position;iterator old_finish=finish;if(elems_after>n){//(1)、"插⼊点之后的现有元素个数"⼤于"新增元素个数"(见图1)//①从finish处开始复制范围(finish-n,finish)的元素uninitialized_copy(finish-n,finish,finish);finish+=n; //②vector尾部后移//③将范围(position,old_finish-n)的元素移到(,old_finish)处copy_backward(position,old_finish-n,old_finish);//④从插⼊点开始填⼊元素fill(position,position+n,x_copy);}else{//(2)、"插⼊点之后的现有元素个数"⼩于"新增元素个数"（见图2）//①从finish处复制n-elems_after个元素x_copyuninitialized_fill_n(finish,n-elems_after,x_copy);finish+=n-elems_after; //②vector尾部后移//③从finish处开始复制范围(position,old_finish)的元素uninitialized_copy(position,old_finish,finish);finish+=elems_after; //④vector尾部后移//⑤从插⼊点开始填⼊元素fill(position,old_finish,x_copy);}}else{//备⽤空间⼤于等于"新增元素",即必须配置额外空间//⾸先决定新长度，旧长度的两倍，或者旧长度+新长度（见图3）const size_type old_size=size();const size_type len=old_size+max(old_size,n);//以下配置新的vector空间iterator new_start=data_allocator::allocate(len);iterator new_finish=new_start;__STL_TRY{//①先将旧的vector的插⼊点之前的元素复制到新的空间new_finish=uninitialized_copy(start,position,new_start);//②再将新增的元素填⼊新空间new_finish=uninitialized_fill_n(new_finish,n,x);//③再将旧vector的插⼊点之后的元素复制到新空间new_finish=uninitialized_copy(position,finish,new_finish);}#ifdef __STL_USE_EXCEPTIONScatch(...){//如果发现异常，实现rollbackdestory(new_start,new_finish);data_allocator::deallocate(new_satrt,len);throw;}#endif /*__STL_USE_EXCEPTIONS*///以下清除并释放旧的vectordestory(start,finish);deallocate();//调整⽔位标记start=new_start;finish=new_finish;end_of_storage=new_start+len;}}}}图1图2图3。

侯捷stl源码剖析注释之26 sgi-stl-function

<stl_function.h> 完整列表 The Annotated STL Sources 1G++ 2.91.57，cygnus\cygwin-b20\include\g++\stl_function.h 完整列表/*** Copyright (c) 1994* Hewlett-Packard Company** Permission to use, copy, modify, distribute and sell this software* and its documentation for any purpose is hereby granted without fee,* provided that the above copyright notice appear in all copies and* that both that copyright notice and this permission notice appear* in supporting documentation. Hewlett-Packard Company makes no* representations about the suitability of this software for any* purpose. It is provided "as is" without express or implied warranty.*** Copyright (c) 1996* Silicon Graphics Computer Systems, Inc.** Permission to use, copy, modify, distribute and sell this software* and its documentation for any purpose is hereby granted without fee,* provided that the above copyright notice appear in all copies and* that both that copyright notice and this permission notice appear* in supporting documentation. Silicon Graphics makes no* representations about the suitability of this software for any* purpose. It is provided "as is" without express or implied warranty.*//* NOTE: This is an internal header file, included by other STL headers.* You should not attempt to use it directly.*/#ifndef __SGI_STL_INTERNAL_FUNCTION_H#define __SGI_STL_INTERNAL_FUNCTION_H__STL_BEGIN_NAMESPACE// C++ Standard 規定，每一個 Adaptable Unary Function 都必須繼承此類別template <class Arg, class Result>struct unary_function {typedef Arg argument_type ;typedef Result result_type ;};// C++ Standard 規定，每一個 Adaptable Binary Function 都必須繼承此類別template <class Arg1, class Arg2, class Result>struct binary_function {typedef Arg1 first_argument_type ;typedef Arg2 second_argument_type ;typedef Result result_type ;<stl_function.h> 完整列表The Annotated STL Sources 2};// 以下6個為算術類（Arithmetic ）仿函式template <class T>struct plus : public binary_function <T, T, T> {T operator()(const T& x, const T& y) const { return x + y; }};template <class T>struct minus : public binary_function <T, T, T> {T operator()(const T& x, const T& y) const { return x - y; }};template <class T>struct multiplies : public binary_function <T, T, T> {T operator()(const T& x, const T& y) const { return x * y; }};template <class T>struct divides : public binary_function <T, T, T> {T operator()(const T& x, const T& y) const { return x / y; }};// 所謂運算op 的證同元素（identity element ）是指，數值A 與此元素做op 運算，// 會得到A 自己。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

侯捷老师——STL源码剖析
侯捷老师是国内知名的C++专家，他在C++领域有着很高的知名度和
影响力。

他的《STL源码剖析》是一本非常经典的C++书籍，深入剖析了
C++标准模板库（Standard Template Library，STL）的源代码，并详细
解释了其设计思想和实现细节。

下面是对这本书的1200字以上的介绍。

《STL源码剖析》是一本写给C++程序员的经典著作，它由侯捷老师
亲自编写，内容非常详尽和深入。

这本书主要介绍了C++标准模板库（STL）的源代码，并解析了其中的设计思想和实现细节。

通过阅读这本书，读者可以更好地理解STL的底层原理，提高自己的C++编程能力。

这本书共分为13个章节，每个章节都涉及了STL的不同组件和特性。

书中的内容既包括理论知识，也包括具体的代码实现。

侯捷老师用通俗易
懂的语言和形象生动的例子，对STL的各个组件进行了详细介绍。

他从容器、迭代器、算法和函数对象等方面入手，逐步展开对STL的剖析。

每一
章的结尾都有相关的练习题，读者可以通过做题来巩固所学知识。

在《STL源码剖析》中，侯捷老师对STL的源代码进行了深入分析，
解释了其中的设计思想和实现原理。

他通过对容器的底层结构和操作进行
剖析，揭示了STL的高效性和灵活性。

在对算法和函数对象的讲解中，他
详细介绍了STL中的各种常用算法，并解释了它们的内部实现原理。

通过
这种深入的分析，读者可以更好地理解STL的运作机制，并能够灵活运用STL进行程序设计。

除了对STL源代码的剖析，侯捷老师还对STL的使用和扩展进行了说明。

他介绍了STL的使用注意事项和常见问题，并给出了一些实用的编程
技巧和优化建议。

此外，他还展示了如何扩展STL，给出了一些自定义容
器和算法的示例。

这些内容对于想要深入学习和应用STL的读者来说是非常有价值的。

总的来说，侯捷老师的《STL源码剖析》是一本非常权威和深入的
C++书籍，对于想要深入学习STL的C++程序员来说是一本必读之作。

通过阅读这本书，读者可以更好地理解STL的底层原理和内部实现，提高自己的C++编程能力。

这本书的内容详尽，讲解清晰，适合各个层次的读者阅读。

无论是初学者还是有一定经验的程序员，都能从中受益匪浅。