提示：本文是一篇个人读书笔记，并不是对原书内容的系统总结整理，可能对作者以外的读者没有太大的参考意义。
第一章 C++编程基础
1. 构造函数语法（P8），除了一般的等式初始化外的另一种初始化方法
int num_tries(0)
2.case标签的向下穿越（P19），比较后会一直执行符合的case语句以及下面的所有语句。
3.vector的两种初始化方式(P24-25)
单个元素逐一指定；利用一个已经初始化的array赋值
4.while(infile>>name)何时结束？（P32）
读到文件尾端，infile>>name返回false
5.cin中的setw()（习题，P207）
第二章 面向过程的编程风格
1.传值、传引用（&，P45）、传地址（*，P47）调用，即使不需要修改原数值，也可以使用后两者获得比第一种快的速度，原因是不需要对整个对象进行复制（P47）。后两者主要差异是使用时的用法不同。
2.函数位于程序栈（P48），动态分配（new）位于堆（P49）
3.delete数组方式（P50）： delete []pia;
4.函数默认值设定时，不能将引用设置为0，它必须代表某个对象。（P51）
5.模板函数用法（P59）
6.头文件（P63）：inline函数应定义于头文件(P63)；const对象（非指针）只在文件内作用(P64)。
7.习题2.6注意把max函数换个名字，否则与std命名空间冲突。
第三章 泛型编程风格
1.iterator定义形式（以vector为例）（P74）：
vector<string> svec;
vector<string>::iterator iter = svec.begin();
衍生的const形式：
const vector<string> cs_vec;
vector<string>::const_iterator = cs_vec.begin();
2.泛型函数：以find()为例(P75)
利用了模板函数写成，能够支持不同容器的使用。
3.三种序列式容器对象(P78)：list、vector、deque
4.设计泛型算法的演化（P83~89）：这部分如果只读书读不懂，还是按照演化过程把代码写一遍比较好理解。P93～94是对这一节的进一步扩充。
5.勘误：习题3.2(P221)在vector<elemType>前需要加typename。
第四章 基于对象的编程风格
1.class的无参数初始化是T t而不能用T t()，后者是个函数定义。
T t=8相当于调用单一参数的构造函数。(P105)
2.第二种构造函数constructor初始化语法：成员初值表member initialization list（P106）
在习题里提到的，类定义里，构造函数默认参数列表还能这么写：Triangular(int=1,int=1)
3.member function的const修饰符：告诉编译器其不会更动其调用者。放置于参数表后。(P110)
P111提供了member function的const版本和非const版本，并说明了如何分别调用二者。
更进一步的补充是mutable关键字，告诉编译器改变其所修饰的变量不会改变类的常数性，因此可以在用const修饰的member function中修改。
4.this指针会由编译器自动地将其加到每一个member function的参数列表中，函数体内也会发生这种转换。(P114)
5.只有在member function不存取任何non-static members的条件下才能够被声明为static(P116)，在类外定义时不需要再加static（P117）
类的static成员变量必须在文件中初始化。
6.附注：本章正文代码实际上是自己编写了个只适用于Triangular类的iterator，并对它重载了*、++等运算符。这些内容体现在下面的代码中，大部分是按照原书正文写的，小部分是按照原书提供的源码补充的。
chapter4
/* * ===================================================================================== * Filename: ConstAndMutableClass.cpp * Description: * Version: 1.0 * Created: 2013年04月16日 17时29分08秒 * Author: wuyue (wy), vvuyve@gmail.com * Company: UESTC * ===================================================================================== */ #include <iostream> #include <vector> #include <algorithm> #include <string> using namespace std; class Triangular_iterator { public: Triangular_iterator(int index):_index(index-1){} bool operator==(const Triangular_iterator& ) const; bool operator!=(const Triangular_iterator& ) const; int operator*() const; Triangular_iterator& operator++(); Triangular_iterator operator++(int); private: void check_integrity() const; int _index; }; // notice: //1.kinds of constructor,P105 //2.constructor with member initialization list,P106 //3.function with const after its parameter list,P110 //4.mutable,P112 //5.static functions,P116 class Triangular { friend class Triangular_iterator; public: //const member functions int length() const {return _length;} int beg_pos() const {return _beg_pos;} int elem(int pos) const; //non-const member functions void length(int nlen) {_length = nlen;} void beg_pos(int npos) {_beg_pos = npos;} bool next(int &val) const; void next_reset() const {_next = 1;} //constructor Triangular(int=1,int=1); //Triangular(int l=1, int bp=1) is usually form Triangular(const Triangular &rhs); Triangular& operator=(const Triangular &rhs); Triangular& copy(const Triangular &rhs); static bool is_elem(int); static void gen_elements(int length); static void gen_elems_to_value(int value); static void display(int length, int beg_pos, ostream &os = cout); typedef Triangular_iterator iterator; Triangular_iterator begin() const { return Triangular_iterator(_beg_pos); } Triangular_iterator end() const { return Triangular_iterator(_beg_pos+_length); } private: int _length; int _beg_pos; mutable int _next; static const int _max_elems = 1024; static vector<int> _elems; }; //a static member must be initalized //whether it in its class or not vector<int> Triangular::_elems; int Triangular::elem(int pos) const {return _elems[pos-1];} bool Triangular::next(int &value) const { if(_next<_beg_pos+_length-1) { value = _elems[_next++]; return true; } return false; } Triangular& Triangular:: operator=( const Triangular &rhs ) { if ( this != &rhs ) { _length = rhs._length; _beg_pos = rhs._beg_pos; _next = 1; } return *this; } //Member Initialization List,P106 Triangular::Triangular(const Triangular &rhs) :_length(rhs._length),_beg_pos(rhs._beg_pos),_next(rhs._next) {} Triangular::Triangular(int len,int beg_pos) : _length(len>0?len:1), _beg_pos(beg_pos>0?beg_pos:1) { _next=_beg_pos; int elem_cnt = _beg_pos + _length; if(_elems.size()<elem_cnt) gen_elements(elem_cnt); } bool Triangular::is_elem(int value) { if(!_elems.size()||_elems[_elems.size()-1]<value) gen_elems_to_value(value); vector<int>::iterator found_it; vector<int>::iterator end_it = _elems.end(); found_it = find(_elems.begin(),end_it,value); return found_it!=end_it; } void Triangular:: gen_elems_to_value( int value ) { int ix = _elems.size(); if ( !ix ){ _elems.push_back( 1 ); ix = 1; } while ( _elems[ ix-1 ] < value && ix < _max_elems ) { //cout << "elems to value: " << ix*(ix+1)/2 << endl; _elems.push_back( ix*(ix+1)/2 ); ++ix; } if ( ix == _max_elems ) cerr << "Triangular Sequence: oops: value too large " << value << " -- exceeds max size of " << _max_elems << endl; } void Triangular:: gen_elements( int length ) { if ( length < 0 || length > _max_elems ){ cerr << "Triangular Sequence: oops: invalid size: " << length << " -- max size is " << _max_elems << endl; return; } if ( _elems.size() < length ) { int ix = _elems.size() ? _elems.size()+1 : 1; for ( ; ix <= length; ++ix ) _elems.push_back( ix*(ix+1)/2 ); } } Triangular& Triangular::copy(const Triangular &rhs) { if(this!=&rhs) { _length=rhs._length; _beg_pos=rhs._beg_pos; _next=rhs._next; } return *this; } //operator relaoded inline bool Triangular_iterator:: operator==(const Triangular_iterator &rhs) const {return _index == rhs._index;} inline bool Triangular_iterator:: operator!=(const Triangular_iterator &rhs) const {return !(*this == rhs);} class iterator_overflow{}; inline void Triangular_iterator:: check_integrity() const { if(_index>= Triangular::_max_elems) throw iterator_overflow(); if(_index>=Triangular::_elems.size()) Triangular::gen_elements(_index + 1); } inline int Triangular_iterator:: operator*() const { check_integrity(); return Triangular::_elems[ _index ]; } inline Triangular_iterator& Triangular_iterator:: operator++() { ++_index; check_integrity(); return *this; } inline Triangular_iterator Triangular_iterator:: operator++(int) { Triangular_iterator tmp = *this; ++_index; check_integrity(); return tmp; } void Triangular:: display( int length, int beg_pos, ostream &os ) { if ( length <= 0 || beg_pos <= 0 ){ cerr << "invalid parameters -- unable to fulfill request: " << length << ", " << beg_pos << endl; return; } int elems = beg_pos + length - 1; if ( _elems.size() < elems ) gen_elements( elems ); for ( int ix = beg_pos-1; ix < elems; ++ix ) os << _elems[ ix ] << ' '; } ostream& operator<<(ostream &os,const Triangular &rhs) { os<<"("<<rhs.beg_pos()<<","<<rhs.length()<<")"; rhs.display(rhs.length(),rhs.beg_pos(),os); return os; } istream& operator>>(istream &is,Triangular &rhs) { char ch1,ch2; int bp,len; is>>ch1>>bp>>ch2>>len; rhs.beg_pos(bp); rhs.length(len); rhs.next_reset(); return is; } int sum(const Triangular &trian) { if(!trian.length()) return 0; int val,sum = 0; trian.next_reset(); while(trian.next(val)) sum+=val; return sum; } //Page 113 int proc1() { Triangular tri(4); cout<<tri<<"-sum of elements:" <<sum(tri)<<endl; Triangular tri2(4,3); cout<<tri2<<"-sum of elements:" <<sum(tri2)<<endl; Triangular tri3(4,8); cout<<tri3<<"-sum of elements:" <<sum(tri3)<<endl; return 1; } //Page 117 int proc2() { char ch; bool more = true; while (more) { cout<<"Enter value:"; int ival; cin>>ival; bool is_elem = Triangular::is_elem(ival); cout<<ival<<(is_elem?" is ":" is not ") <<"an element in the Triangular series.\n" <<"Another value?[y/n]"; cin>>ch; if(ch=='n'||ch=='N') more = false; } return 1; } //Page 125 int proc3() { Triangular tri(20,12); Triangular::iterator it = tri.begin(); Triangular::iterator end_it = tri.end(); cout<<"Triangular Series of "<<tri.length()<<" elements\n"; cout<<tri<<endl; while(it!=end_it) { cout<<*it<<' '; ++it; } cout<<endl; return 1; } //Page 129 int proc4() { Triangular tri(6,3); cout<<tri<<'\n'; Triangular tri2; cin>>tri2; cout<<tri2; return 1; } int main() { int select; string notice= "Please input the number for a test\n \ a non-number input for quit.\n \ 1.Page 113\t2.Page 117\t3.Page 125\t4.Page 129\n"; cout<<notice; cin>>select; while(cin) { switch (select) { case 1: proc1(); break; case 2: proc2(); break; case 3: proc3(); break; case 4: proc4(); break; default: cout<<"undefined num."; } cout<<notice; cin>>select; } }
7.习题4.5要求重载一些运算符。怎么安排这些函数的位置呢？可参考：http://blog.csdn.net/insistgogo/article/details/6626952
第五章
1.面向对象编程风格的独特概念：继承(P135)、多态(P137)、动态绑定(P137)
2.P142~145展示了不使用面向对象的继承实现的多态，这种多态是可以用C的struct实现的，不过实现过程和后续维护十分麻烦。
3.抽象基类的三步设计：子类共通行为、找出哪些是与与型别相依的操作、找出每个操作的存取层级。（P145~146）
4.一旦一个类拥有纯虚函数，那么程序无法为它产生任何对象；析构函数最好不要声明为纯虚函数。(P147)
5.派生类用来覆写基类同名函数必须类型、参数、修饰符(是否为const)完全吻合才能在调用时使用，否则仍然使用基类函数(P161~162)。例外：如果基类的虚拟函数返回某个基类形式（通常为pointer或reference）时，派生类的同名函数便可返回基类的派生类的型别(P162)。
6.在单一对象中展现多种型别的方式是通过基类的pointer和reference。传值时非基类部分会被切掉。(详细解释参考P163)
7.类指针的转换方式：static_cast和dynamic_cast（P165）
第六章
1.class template使用成员初始化列表初始化比在构造函数体内赋值更好：P173
2.reference to pointer参数(P177)
3.常量表达式作为template的参数(P181)
4.成员模板函数：如名称，在class内部声明的template函数。
第七章
1.“异常”是某种对象（P192），只有符合catch指定类型的对象才会被捕捉(P193)。
2.重抛异常：catch里使用throw(P194)
3.为了管理函数执行时分配额资源，使其在出现异常时能够回收，C++发明者引入所谓资源管理手法，初始化索取资源应在构造函数中完成，回收由析构函数完成，并且所有局部对象的析构函数都会被调用。（P199）
4.auto_ptr会自动delelet用过new配置的对象，需要memory头文件(P200)。
5.使用exception基类的指针可以捕捉所有的派生异常类。