为什么？因为这是一次方法论的学习过程，而不仅仅是一种语言的学习。

读着本书，按郭德纲的话说，得有过日子的心，就一页一页读下去，体会，反省，动手练习。

具体到我，我看的是英文第四版，用的编译器是MinGW。这本书不仅可以学习C++，也是一本很好的学习英语的教材。英语很地道，而且对于词汇量的要求也不是很高（相对Martin大叔的书来说）。

之所以选择MinGW只是因为它“轻”，因为我平时主要是用Java和C，其实工作中是没啥机会使用C++的。为了把主要精力放在C++本身，所以并没有用VC之类庞大的IDE工具。

我看书的进度的确不算快，只有周一到周五这5天，周六、周日都用在和huohuo鬼混上，基本上没啥精力看书了。

在看“C++ primer”的这4个月的时间里我还在业余时间里做了两个小项目。所以看书的时间并不是很规律。但是我的经验就是坚持。

我很享受这4个月的时光。有时，我觉得这书咋像小说一样好看呢，上下班的路上，我都想下一页大师会讲些啥呢？有时，写着写着java,甚至有些恍惚，偶尔想，这要是C++多好，可以这样这样写了。

感谢Lippman，带给我的快乐。Bye-Bye。

13.1 The Copy Constructor

首先，这真是一个有趣的命题。我老喜欢。这让我想起的是Java的clone。（写下这句话时我还没有看这一节，只是一个预感）

过瘾啊。（写下这句话时我刚刚读完这一节，还没有来得及整理笔记，理顺思路）

什么叫做拷贝构造函数？

拷贝构造函数有一个形参，并且这个形参是指向同一个类的对象的引用。（The constructor that takes a single parameter that is a (usually const) reference to an object of the class type itself is called the copy constructor.）

对象定义的形式

c++支持两种形式的初始化：

1.      直接初始化，使用初始化式（initializer），直接调用对应的构造函数。

2.      拷贝初始化，使用’=’。先调用构造函数生成临时对象，然后再调用拷贝构造函数把临时对象拷贝到我们要创建的对象里。（Copy-initialization first uses the indicated constructor to create a temporary object. It then uses the copy constructor to copy that temporary into the one we are creating）

对于类的对象，当指定单一的实参或者为了拷贝明确构建临时对象时，才能使用拷贝初始化。（For objects of class type, copy-initialization can be used only when specifying a single argument or when we explicitly build a temporary object to copy.）

额外唠唠Sales_item item = string("9-999-99999-9");

只有当Sales_item的构造函数中没有把Sales_item(const string&)这个构造函数声明为explicit时，这个初始化才正确。这其中包含了一个隐式的类型转换：由实参string("9-999-99999-9");生成Sales_item类型的对象，然后再调用copy函数拷贝给item。

但是（咋这么多但是呢）如果这么写Sales_item item2 = item;就又不一样了。这样就变成了调用赋值操作符。

合成复制构造函数

复制构造函数是逐成员拷贝（memberwise copy）。

即使我们不能对array进行copy，但是如果一个类包含有数组类型的成员，合成的复制构造函数也会拷贝这个的数组。数组中的每个元素都会进行复制。（Even though we ordinarily cannot copy an array, if a class has a member that is an array, then the synthesized copy constructor will copy the array. does so by copying each element.）

自定义拷贝函数

阻止拷贝

方法：就是把拷贝函数声明为private。

大多数类都应该定义拷贝构造函数和默认构造函数。

如果一个类里面定义了一个构造函数，编译期就不会再为这个类生成默认构造函数，而需要自己来定义了。

温习一下什么是默认构造函数：（唉，忘记的真快啊）

默认构造函数没有形参。如果定义的对象不提供初始化式（initializer）就会调用默认构造函数。（The default constructor is used whenever we define an object but do not supply an initializer.）

如果一个构造函数为所有形参提供缺省的实参，也可以叫做是默认构造函数。（A constructor that supplies default arguments for all its parameters also defines the default constructor.）

13.2 The Assignment Operator

如果类自己没有定义赋值操作符，那么编译器合成赋值操作符。（注意，这活是编译器干的）

重载操作符（overloaded operators）

操作符重载的形参列表（这里要包括this形参，如果操作符是成员函数的话）以及返回值必须和操作符所需要的操作数相同。

这句话咋理解呢？

1.            形参列表

操作符’=’是二元操作符，它的操作数是两个：第一个操作数是左边的操作数，第二个操作数是右边的操作数。上面这个例子，如果我们需要重载’=’，第一个操作数是被绑定到this指针上，第二个操作数是一个Sales_item类型的对象一般来说，右边操作数一般都是作为const引用传递。（Usually, the right-hand operand is passed as a const reference.）。

Sales_item& operator=(const Sales_item &);

2.            返回值

赋值操作符的返回值类型应该和内置类型的返回值类型相同。（The return type from the assignment operator should be the same as the return from assignment for the built-in types）内置类型的赋值返回的是左操作数的引用，因此赋值操作符也必须返回和它的类类型相同的引用。具体到Sales_item，’=’操作符重载的返回值是Sales_item的引用。

合成赋值操作符

合成赋值操作符也是逐个成员赋值（memberwise assignment）。对于数组是对每个元素进行赋值。

13.3 The Destructor

什么时候调用析构函数？

以上这个例子说明在两种情况下会调用析构函数：

1. 当变量在作用域范围之外的时候，自动被撤销（destroied）
2. 指向对象的指针被删除（deleted），这个对象也就被撤销（destroied）

进一步说明的是指向对象的指针或者是引用即使出了作用域，析构函数也是不会被执行的。就还是以上面的例子来说明：

ghost这个小鬼即使出了作用域实际上也是没有被删除滴，占用的内存空间也是没有被释放滴。这样的程序跑上N遍，机器就会想老牛一样慢了。哎：（

另外当容器撤销时，容器中的元素的析构函数也会被调用（Destructors are also run on the elements of class type in a container - whether a library container or built-in array - when the container is destroyed）

啥时需要写显式的析构函数

析构函数用来释放构造函数或对象生存周期内所需的资源( Ordinarily they are used to relinquish resources acquired in the constructor or during the lifetime of the object.)

另外析构函数也不仅仅是用来释放资源。析构函数可以执行类设计者希望执行的任何操作，这些操作和类对象使用完毕之后执行。（A destructor is not limited only to relinquishing resources. A destructor, in general, can perform any operation that the class designer wishes to have executed subsequent to the last use of an object of that class.）

首要原则是：如果类需要析构函数，那么它一定也需要拷贝构造函数（copy constructor）和赋值操作符（assignment operator）。

合成析构函数

析构函数和拷贝构造函数（copy constructor）和赋值操作符（assignment operator）不同，就是即使你定义了自己的析构函数，当delete时，先调用你自己的析构函数，然后还是要调用合成的析构函数（synthesized destructor）。

析构函数执行的顺序：和构造函数恰恰相反。按照成员在类里面定义的相反的顺序撤销成员。（it destroys the members in reverse order from which they are declared in the class. For each member that is of class type, the synthesized destructor invokes that member's destructor to destroy the object.）

自定义析构函数和合成析构函数的执行顺序：先自定义析构函数，然后再执行合成析构函数。

13.4 A Message-Handling Example

需求描述：

1. 新建Message：是和folder无关的，通过调用save把Message保存到指定的folder。一个Message可以同时属于不同的folder。因此Message中就包含了一个folder的指针集合。另外每个folder里也要包括指向这条Message的指针。
2. copy Message：包括拷贝Message的文本内容以及一系列的folder指针。同时对于每个folder也要追加一个指向拷贝后的Message的指针。
3. 赋值操作（assignment）：这个最搞:D。先要把等号左边的message对象从folder中删除，再删除对象；然后把右边message对象的文本内容和folder拷贝过来，同时还要向folder指针追加指向左边message的指针。
4. destroy：除了要撤销这个Message对象，同时也要删除掉各个folder里面指向这个Message的指针。

大师抽象出来两个操作：

1. 把message从folder中删除：

void remove_Msg_from_Folders();

2. 把message追加到指定的folider：

void put_Msg_in_Folders(const std::set<Folder*>&);

拷贝构造函数

如果我们定义自己的拷贝构造函数，那么我们必须显式拷贝任何我们想要拷贝的成员，因为显式定义考别构造函数是不会自动拷贝任何东西的。（When we write our own copy constructor, we must explicitly copy any members that we want copied. An explicitly defined copy constructor copies nothing automatically.）就是说你要打算自己干就全部自己干，别指望编译器会为你拾遗补缺。

13.5 Managing Pointer Members

Smart Point

大师给出的办法就是对指针进行封装，定义一个新类，它包含有指针，以及使用的次数。下面这个类的定义高！实在是高！就是这个友元的定义。

拷贝控制成员copy-control members

包含指针成员的对象经常需要定义拷贝-控制成员。（Objects with pointer members often need to define the copy-control members.）

拷贝-控制成员包括:

l 赋值操作（assignment operator）

l 析构函数

l 拷贝构造函数（copy constructor）

smart pointer类，使用计数器来管理它smart pointer类。拷贝-控制成员都会影响计数器的值。

复习澄清一下：

l ‘.’点操作符，’*’解引用操作符的优先级

‘.’点操作符的优先级高于解引用，所以要这样子写：

l valuelike classes和pointlike classes有什么区别？

这仅仅是一种很说法而已，valuelike classes，它的值copy后实际上是对应两个对象；而pointlike classes，copy的是指针，因此copy后实际上是指向的同一个对象。

12.1. 类的定义和声明 Class Definitions and Declarations

类定义

大师仅仅写了这么一个类定义的简单的例子，却有这么多的东西可以说说啊

·       Member: data, functions or type definitions.

·       构造函数Constructors初始化：

这种写法是初始化内置数据类型。

·                 const:表示functions不会修改数据成员。这可以用在查询或者判断类型的functions上。

·       成员函数member functions必须在类的内部声明，成员函数的定义是否放在类定义里面是可选的。如果放在类里面，那么

数据抽象和封装Data Abstraction and Encapsulation

类背后蕴涵的基本思想是数据抽象和封装。（The fundamental ideas behind classes are data abstraction and encapsulation.）数据抽象这种技术依赖于接口和实现的分离。（Data abstraction is a programming (and design) technique that relies on the separation of interface and implementation.）

多么精炼的话，包含了面向对象的深刻含义。大师啊。

类的用户（user of class）是谁？程序员programmer。user of class就如同user of application。

类的用户最关心啥？最关心的是接口。

关于类定义的更多内容 more on class definitions

使用Typedef简化类

注意：

typedef是放在public部分的，这样Screen的用户都能够使用这个typedef。

成员函数可被重载Member Functions May Be Overloaded

显式指定 inline 成员函数Explicitly Specifying inline Member Functions

成员函数定义为inline。这个定义即可以在函数声明里，也可以在类定义之外。在类声明和类定义里把函数指定为inline都是合法的。（It is legal to specify inline both on the declaration and definition.）

类声明与类定义

类定义一般要放在头文件中。

类声明后，即使没有类定义，也可以作为引用或者指针来使用：

LinkScreen定义完成之前，我们就定义了指向LinkScreen类型的指针。

这里引入了两个基本感念：

前向声明forward declaretion：

这就是一个前向声明。表示Screen是一个类类型（class type）。

不完全类型incompete type：在前向声明之后，类定义之前Screen就是一个不完全类型。意思是说知道Screen是个类型，但是不知道这个类型包括那些成员（members）。不完全类型只能用在有限的几种方式，它可以用来定义这种类型的指针或者是引用，也可以用在把这种类类型作为形参或者返回值类型的函数声明。（An incomplete type may be used to define only pointers or references to the type or to declare (but not define) functions that use the type as a paremeter or return type.）

在创建某个类类型的对象前，这个类类型必须完整定义。这样编译器餐能够知道要为这种类型的对象保留多大的存储空间。

12.2 隐含的this指针 The Implicit this Pointer

何时使用this？

简单的说，就是当我们需要引用整个对象而不是对象中的成员的时候。最常见的情况是在返回值是被调用的对象的引用的函数里。（when we need to refer to the object as a whole rather than to a member of the object. The most common case where we must use this is in functions that return a reference to the object on which they were invoked.）

this是指针，因此如果返回值是当前对象的引用，那么返回语句一定是：

刚开始看到这个的时候，总是和Java搞混，因为Java是没有指针，所以返回的只能是this，显式使用的时候也是this。

从const成员函数里返回*this

这里有两个规则：

1. 对于一般的非const成员函数，this的类型是一个const pointer。这意味我们可以修改this指向的对象的值，但是不能修改this保存的地址。（In an ordinary nonconst member function, the type of this is a const pointer to the class type. We may change the value to which this points but cannot change the address that this holds.）
2. 对于const成员函数，this的类型是一个指向const 对象的const pointer。这意味我们既不可以修改this指向的对象的值，也不能修改this保存的地址。（In a const member function, the type of this is a const pointer to a const class-type object. We may change neither the object to which this points nor the address that this holds.）

基于const的重载

可以定义两个操作，一个是const，另一个不是，这也算是重载。

这样const对象使用const成员函数；非const对象可以使用任一成员函数，不过最好还是使用非const的成员函数。

对比下面的例子（基于指针形参是否指向const的函数重载）：

可变数据成员Mutable Data Members

即使对象是const，有时我们也希望其中的某些数据成员是可以修改的，这就引出了mutable。

可变数据成员绝不是const，即使对象是const。这样const的成员函数也是可以修改可变数据成员的。

定义：

12.3 类的作用范围

12.4构造函数Constructors

构造函数不能声明为const。

建议的方法：使用构造函数初始化式Constructor Initializer。

Constructor Initializer

以下是正确的写法：

但是这种写法乍一看似乎和下面不使用Constructor Initializer的效果一样：

NO，NO，不一样。后一种写法那就像郭德纲相声说的房都烧没了，就剩下个防盗门，于谦还开门进去。isbn的初始化是在构造函数执行之前完成的。上面这个写法先用缺省的string的构造函数初始化isbn，在构造函数的函数体执行时，isbn又重新赋值为book。没效率啊！但是对于内置类型来说，两种方式无论是在结果上还是在性能上又都是没有区别的。

构造函数的执行分成两个步骤：

1. 初始化阶段，类的数据成员是在这个阶段初始化的。
2. 一般计算阶段，这就是指构造函数函数体的执行。

在计算阶段前初始化阶段就开始了。（Initialization happens before the computation phase begins.）

在一些特定的情况下必须使用Constructor Initializer，这些特殊的情况包括：

1. 数据成员没有缺省的构造函数
2. 数据成员是const或者是引用

for example:

正确写法：只有用constructor initializer才有机会对const和引用进行初始化。

成员初始化顺序

成员的初始化顺序就是成员的定义的顺序。第一个定义的成员第一个初始化，然后是下一个，以此类推。（The order in which members are initialized is the order in which the members are defined. The first member is initialized first, then the next, and so on.）

类类型的数据成员的初始化Initializers for Data Members of Class Type

Constructor Initializer初始化式使用类的某一个构造函数来完成。

缺省构造函数

只有在类没有定义任何一个构造函数时，编译器才会自动生成缺省的构造函数。

隐式类类型转换 Implicit Class-Type Conversions

12.5. 友元Friends

友元就是允许其它特定的类和方法来访问它的非public的成员。（The friend mechanism allows a class to grant access to its nonpublic members to specified functions or classes.）

友元定义：

友元不是类的成员，但是他们是类的接口的组成部分。（even if they are not members of the class, they are "part of the interface" to the class.）

友元可以是：

l 类

l 类的成员函数

l 一般的非成员函数

友元声明和范围

友元声明和友元定义之间存在的相互依赖关系使得我们小心地构造类。再看上面的例子:

Window_Mgr必须要的Screen前定义。但是成员方法relocate要在Screen定义后才能定义。靠，这就像是先有蛋还是先有鸡一样拧巴。

12.6. static 类成员static Class Members

这句话是对static class member的最重要的解释：

静态数据成员独立于类的任何对象而存在，每个静态数据成员是和类相关的对象，而不是和类的对象相关。（a static data member exists independently of any object of its class; each static data member is an object associated with the class, not with the objects of that class.）

使用静态数据成员的好处

l static成员的名字的作用范围是类，因此可以避免和其它的类的成员或者全局对象的名字的冲突。

l 强制进行封装。static成员可以是private的，而全局对象是不可以的。

l 如果把static成员关联到某个特殊的类上，这样易于阅读代码。

静态成员函数static member function

在静态成员函数（static member function）中是不能使用this指针的。这其实很好理解，因为this指针指向的是对象，而静态成员函数并不属于任何的对象。

静态数据成员static data members

静态数据成员可以是任何的类型：const，引用reference，数组，指针类。

以上是一个完整的static的定义，要注意以下几点：

1.      静态数据成员要在类定义体之外来定义。（static data members must be defined (exactly once) outside the class body.）

2.      静态成员不能通过构造函数进行初始化，而是在定义的时候就完成了初始化。（static members are not initialized through the class constructor(s) and instead should be initialized when they are defined.）

3.      关键字static只是用在类体内的成员声明，而当在类的外面的对静态数据成员进行定义时，就不要再使用关键字static。（The static keyword, however, is used only on the declaration inside the class body. Definitions are not labeled static.）

整型类型的静态数据成员可以在类定义体内直接定义，只要是初始化值是常量表达式。

a const static data member of integral type can be initialized within the class body as long as the initializer is a constant expression

period的定义就是这样：

注意：虽然period在类定义体内完成了初始化，但是还是要在类定义之外定义数据成员。（When a const static data member is initialized in the class body, the data member must still be defined outside the class definition.）

静态成员不是类对象的一部分

也正因为如此，对于非静态成员的非法的使用方式，对于静态成员来说就是合法的。例如：静态成员的类型可以是它所属类的类型。非静态数据成员被严格限制只能是它所属类的对象的引用或者是指针。（the type of a static data member can be the class type of which it is a member. A nonstatic data member is restricted to being declared as a pointer or a reference to an object of its class:）

泛型算法

算法为了保持独立性，不使用容器类型，而使用迭代器。

算法绝不执行容器操作。算法仅仅是根据迭代器和迭代器操作来操作的。因此所有会改变迭代器的操作在通用算法里都不会出现。例如增加或删除元素。但是这些通用算法有可能会修改容器中元素的值，也可能会在容器中移动元素。

11.2 初窥算法

必须要包含一下的头文件：

#include <algorithm>

#include <numeric>

只读算法

accumulate

这个算法的参数很好说明了算法实际上是不知道元素的类型的。第三个参数指定了起始值，因为accumnulate不知道它正在汇总的元素的类型。

int sum = accumulate(vec.begin(), vec.end(), 42);

另一个例子：

string sum = accumulate(v.begin(), v.end(), string(""));

这里一定要指定起始值是string，而绝不能写成字符串常量，因为字符串常量对应的数据类型是const char*。

有趣！

find_first_of

需要两对迭代器：

size_t cnt = 0; list<string>::iterator it = roster1.begin(); // look in roster1 for any name also in roster2 while   ((it = find_first_of(it, roster1.end(),              roster2.begin(), roster2.end()))                 != roster1.end()) {    ++cnt;    // we got a match, increment it to look in the rest of roster1    ++it; }

roster1是list，roster2可以是deque，vector，只要我们可以用==操作比较这两个序列中的元素。尤其是：如果 roster1 是 list<string> 对象，则 roster2 可以是 vector<char*> 对象，因为 string 标准库为 string 对象与 char* 对象定义了相等（==）操作符。

总结一下迭代器实参类型

l 标记范围的两个实参类型必须精确匹配，必须指向同一个容器中的元素（或者超出容器末端的下一位置），并且如果两者不相等，则第一个迭代器通过不断地自增，必须可以到达第二个迭代器。

l 带有两对迭代器参数。每对迭代器中，两个实参的类型必须精确匹配，但不要求两对之间的类型匹配。特别是，元素可存储在不同类型序列中，只要这两序列的元素可以比较即可。

写容器算法

写容器算法最重要的一点是必须保证算法所写的序列至少要和被写入的元素数目一样大。（we must take care to ensure that the sequence into which the algorithm writes is at least as large as the number of elements being written.）就是说如果指定的要写入的序列范围必须是有效的，必须大于要写入的元素数目，就是说不能越界。

看个最一目了然的例子就是：

vector<int> vec; // empty vector // disaster: attempts to write to 10 (nonexistent) elements in vec fill_n(vec.begin(), 10, 0);

back_inserter

使用back_inserter之所以安全，是因为如果指定的范围越界，它执行的并不是数据修改操作而是数据添加操作。

容器元素重新排序算法

unique

sort

stable_sort

谓词predicates

再次解读迭代器Iterators

三类迭代器：

l insert iterators插入迭代器

l iostream iterators

l reverse iterators反向迭代器

insert iterators

inserter是迭代器适配器，它和容器绑定，产生一个迭代器，这个迭代器向绑定的容器插入元素。当我们通过inserter迭代器赋值时，迭代器插入新的元素。（An inserter is an iterator adaptor that takes a container and yields an iterator that inserts elements into the specified container. When we assign through an insert iterator, the iterator inserts a new element.）

又分成3类：

• back_inserter：使用push_back创建一个迭代器
• front_inserter: 使用push_front创建一个迭代器
• inserter：在指定的位置后创建迭代器

list<int> ilst, ilst2, ilst3;     // empty lists // after this loop ilst contains: 3 2 1 0 for (list<int>::size_type i = 0; i != 4; ++i)      ilst.push_front(i); // after copy ilst2 contains: 0 1 2 3 copy (ilst.begin(), ilst.end(), front_inserter(ilst2)); // after copy, ilst3 contains: 3 2 1 0 copy (ilst.begin(), ilst.end(), inserter (ilst3, ilst3.begin()));

iostream iterators

istream_iterator:读input stream

ostream_iterator:写output stream

定义流迭代器stream Iterators

流迭代器都是模板Templates。Example:

istream_iterator<int> cin_it(cin);    // reads ints1 from cin istream_iterator<int> end_of_stream; // end iterator value while(cin_it != end_of_stream) {    //do something } // writes Sales_items from the ofstream named outfile // each element is followed by a space ofstream outfile; ostream_iterator<Sales_item> output(outfile, " ");

istream_iterator上的操作

++it & it++

迭代器加1，一般前缀加1，返回的是增加后的迭代器的引用。后缀加1，迭代器也加1，但是返回的是未加1的那个值。

大师给出了一个istream_iterator和ostream_iterator这两种迭代器的最经典的应用，输入转输出，有这个sample这是很容易理解这两个东西：

// write one string per line to the standard output ostream_iterator<string> out_iter(cout, ""n"); // read strings from standard input and the end iterator istream_iterator<string> in_iter(cin), eof; // read until eof and write what was read to the standard output while (in_iter != eof)     // write value of in_iter to standard output     // and then increment the iterator to get the next value from cin    *out_iter++ = *in_iter++;

流迭代器的限制

1.      不能从ostream_iterator中读入数据，同时也不能向istream_iterator写入数据（It is not possible to read from an ostream_iterator, and it is not possible to write to an istream_iterator.）

2.      一旦给ostream_iterator赋值，这个写入的操作就提交了。一旦赋值，在后续的操作中就不能修改。此外，每个ostream_iterator只能用作输出一次。（Once we assign a value to an ostream_iterator, the write is committed. There is no way to subsequently change a value once it is assigned. Moreover, each distinct value of an ostream_iterator is expected to be used for output exactly once.）

3.      在ostream_iterator里没有->操作。

基于流迭代器使用算法

既然流迭代器基本上可以看做一般意义上的迭代器，那么前面所描述的算法应该同时也适用在流迭代器上。于是，针对流迭代器，我们也可以进行排序，比较等算法操作。

istream_iterator<int> cin_it(cin);    // reads ints from cin istream_iterator<int> end_of_stream; // end iterator value // initialize vec from the standard input: vector<int> vec(cin_it, end_of_stream); sort(vec.begin(), vec.end()); // writes ints to cout using " " as the delimiter ostream_iterator<int> output(cout, " "); // write only the unique elements in vec to the standard output unique_copy(vec.begin(), vec.end(), output);

reverse iterators

从这张图上可以看出普通迭代器和反向迭代器的区别，另外二者都能够执行自增和自减操作，形式是一样的，但本质是不同的。例如形式上都是自增，迭代器都会由begin向end方向移动，但是二者却是反方向的。这样做的最大好处是：我们能够透明地使用算法向前或者向后处理容器。

利用迭代器处理string

可以达到java中StringToken的功能：我喜欢这段代码

// find first element in a comma-separated list string::iterator comma = find(line.begin(), line.end(), ','); cout << string(line.begin(), comma) << endl;

反向迭代器获得最后一个单词：

// find last element in a comma-separated list string::reverse_iterator rcomma = find(line.rbegin(), line.rend(), ','); // wrong: will generate the word in reverse order cout << string(rcomma.base(), line.end()) << endl;

反向迭代器可以代表迭代器范围以及这个范围是不对称的事实产生一个重要的结论。当我们用一般的迭代器对反向迭代器初始化或者赋值时，所得到的迭代器所指向的元素和初始值不一样。（The fact that reverse iterators are intended to represent ranges and that these ranges are asymmetric has an important consequence. When we initialize or assign a reverse iterator from a plain iterator, the resulting iterator does not refer to the same element as the original.）

泛型算法结构

Nothing to say。

其实就是对算法进行了分类，同时对于算法的命名习惯加以阐述，看完了，觉得跳过也无妨哈。

容器特有算法

就是针对list，为了性能优化，对于算法，list重新实现。

8.1 An Object-Oriented Library

标准IO库实际上是针对三类流stream的操作

对于IO对象来说是不能拷贝或赋值的，因此这些写法都是会死人的：

l         形参不能是IO类型。返回值也不能是IO类型。

l         IO对象也不能保存在vector这样的集合容器里。

8.2 条件状态Condition States

条件状态成员是做什么用的？

是用来详细地描述当前的流（stream）的状态。例如：是否可用，或者遇到了某种特殊的错误。这些状态信息即可以访问，也可以设置。

每个流对象（stream object）都会包含一个成员（member），这个成员通过setstate和clear操作进行管理。它的类型是iostate。

每个 IO 类还定义了三个 iostate 类型的常量值，分别表示特定的位模式。

strm::badbit：badbit 标志着系统级的故障，如无法恢复的读写错误。

strm::failbit：如果出现的是可恢复的错误，如在希望获得数值型数据时输入了字符，此时则设置 failbit 标志。

strm::eofbit：是在遇到文件结束符时设置的，此时同时还设置了 failbit。

对于IO类的条件状态的操作，不管是查询的，eof(),fail(),bad(),还是赋值操作，clear(),setstate()，应该都是位操作。

8.3 管理输出缓冲 Managing the Output Buffer

哪些条件下buffer会被清空？

1.        The program completes normally. All output buffers are emptied as part of the return from main.

程序正常结束。作为 main 返回工作的一部分，将清空所有输出缓冲区。

2.        At some indeterminate time, the buffer can become full, in which case it will be flushed before writing the next value.

在一些不确定的时候，缓冲区可能已经满了，在这种情况下，缓冲区将会在写下一个值之前刷新。

3.        We can flush the buffer explicitly using a manipulator such as endl, flush, ends.

用操纵符显式地刷新缓冲区，例如行结束符 endl。

4.        We can use the unitbuf manipulator to set the stream's internal state to empty the buffer after each output operation.

在每次输出操作执行完后，用 unitbuf 操作符设置流的内部状态，从而清空缓冲区。

5.        We can tie the output stream to an input stream, in which case the output buffer is flushed whenever the associated input stream is read.

可将输出流与输入流关联（tie）起来。在这种情况下，在读输入流时将刷新其关联的输出缓冲区。

程序崩溃时，缓冲区是不会被刷新的

前提：如果程序非正常结束，输出缓冲（Output buffer）是不会刷新的。

建议：在每个输出都用endl的结尾。

关于endl和"n的区别？

如果简单的从输出上看，二者肯定是没有区别的。但是endl会刷新输出cout的buffer。

输入流和输出流绑定

cin和cout绑定

结果是：任何读输入流的尝试都将首先刷新与之绑定的输出流的缓冲区（buffer）。：

交互系统一定要保证输出流和输入流是绑定在一起的。

8.4 文件输入和输出 File Input and Output

fstream header

l         ifstream

l         ofstream

l         fstream

基本语法格式：

注意：文件名要使用C风格的字符串。

文件流可以和文件重新绑定

l         文件流可以和文件重新绑定。但是在重新绑定前要先关闭流，并清空文件流的状态，否则上一次的文件流的状态就会是重新绑定后的初始状态。

l         关闭流对象，都不可能改变流对象内部的状态。Closing a stream does not change the internal state of the stream object.

文件模式

ios_base::openmode

truncate

当文件打开时清空文件的所有内容，如果使用这个属性对文件至少要有写入的权限

Sample：

这是一个标准的文件重新绑定的代码，包括了以上的注意事项。

8.5 字符串流String Streams

字符串流和文件流其实很类似。独有的就是利用字符串流来实现格式化输入/输出。

输出

输入：

switch

switch语句我用的的确不多，还是习惯写成if-else的形式。

switch 中的控制流：

有2种switch常见的错误写法：

l           case 标号必须是整型常量表达式。

l           如果两个 case 标号具有相同的值，同样也会导致编译时的错误。

Switch内部的变量定义：

对于 switch 结构，只能在它的最后一个 case 标号或 default 标号后面定义变量。

do while语句

用作条件判断的变量一定要定义在循环体之外，

do while 循环不可以采用如下方式定义变量：

不过其实自己写代码时，这个各色的写法一般是不会出现的。

Using the Preprocessor for Debugging（使用预处理器进行调试）

预处理器还定义了其余四种在调试时非常有用的常量：

__FILE__ 文件名

__LINE__ 当前行号

__TIME__ 文件被编译的时间

__DATE__ 文件被编译的日期

断言assert是一种预处理宏，assert 宏就求解条件表达式，如果结果为 false，assert 输出信息并且终止程序的执行。如果该表达式有一个非零（例如，true）值，则 assert 不做任何操作。

尽量不要使用符号数进行位运算，因为符号位的处理和机器有关。

对XOR的描述真是简单明了，For each bit position, the result is 1 if either but not both operands contain 1; Otherwise, the result is 0.

输入输出标准库重载了移位操作符>>和<<用于输入和输出。

复合表达式的求值（Evaluating Compound Expressions）

这里面有两个关键词：

l         Precedence

Precedence specifies how the operands are grouped.优先级规定的是操作数的结合方式

l         associativity

Associativity specifies how to group operators at the same precedence level.结合性规定了具有相同优先级的操作符如何分组。

例如：

赋值操作符是右关联

算数操作符是左关联

5.4 赋值操作符（Assignment Operators）

让你不得不佩服，Lippman这样的大师仅仅赋值操作符（Assignment Operators）就可以讲出这么多的内容。

l         赋值运算是右关联，它的返回值是左操作数；类型为左操作数的类型（The result of an assignment is the left-hand operand, the type of the result is the type of the left-hand operand.）。

这样就好理解这样的赋值语句了：

先执行jval = 0;返回值是jval ，再执行ival = jval。

l         赋值操作的优先级低。

下面的条件语句返回值是true，因为先执行赋值语句，返回值是i，i大于0，因此条件语句判断为true。

下面的条件语句返回值是false，因为先执行赋值语句，返回值是i，i等于0，因此条件语句判断为false。

5.5 Increment and Decrement Operators自增和自减操作符

l         重点

前置和后置操作符

l         建议

只在必要的时候才使用后置操作符。

l         区别

前置和后置操作符的返回值是不同的，这是最重要的区别，也是理解的基础。

前置操作符：值加1，再返回。（It increments the value and returns the incremented version.）

后置操作符：必须保留原始值，（原始值加1）返回的结果是未增加的值。（The postfix operator must store the original value so that it can return the unincremented value as its result.）

l         代码

cnt—的返回值是cnt。

*iter++就是*(iter++)，++操作的优先级高于*，所以先执行iter++，这个操作的返回值是iter，然后iter+1.再执行解引用操作*，这个解引用操作的操作数是返回的iter。

Sizeof

？如果是返回对象的size，那么sizeof的返回值是不是和数据有关？

赋值顺序

l         && 和 || 操作符计算其操作数的次序：当且仅当其右操作数确实影响了整个表达式的值时，才计算这两个操作符的右操作数。

&& and || operators specify the order in which their operands are evaluated: In both cases the right-hand operand is evaluated if and only if doing so might affect the truth value of the overall expression.

（这句话说的真是严谨。）

l         一个表达式里，不要在两个或更多的子表达式中对同一对象做自增或自减操作。

Do not use an increment or decrement operator on the same object in more than two subexpressions of the same expression.

5.11 new 和 delete 表达式（The new and delete Expressions）

new表达式返回的是一个指针，这个指针指向新分配的一个对象。

但是这样写就不是动态分配的指针

后面的写法是不能执行delete表达式的。

由new动态创建的对象一定要执行delete来删除。否则内存就会被耗尽。

大师给了以下的建议：

l         Setting the pointer to 0 after the object it refers to has been deleted makes it clear that the pointer points to no object.（一旦删除了指针所指向的对象，立即将指针置为 0，这样就非常清楚地表明指针不再指向任何对象。）

l         Reading or writing to the object after it has been deleted. This error can sometimes be detected by setting the pointer to 0 after deleting the object to which the pointer had pointed.（读写已删除的对象。如果删除指针所指向的对象之后，将指针置为 0 值，则比较容易检测出这类错误。）

l         Applying a delete expression to the same memory location twice. This error can happen when two pointers address the same dynamically allocated object. If delete is applied to one of the pointers, then the object's memory is returned to the free store. If we subsequently delete the second pointer, then the free store may be corrupted.（对同一个内存空间使用两次 delete 表达式。当两个指针指向同一个动态创建的对象，删除时就会发生错误。如果在其中一个指针上做 delete 运算，将该对象的内存空间返还给自由存储区，然后接着 delete 第二个指针，此时则自由存储区可能会被破坏。）

Arrays and Points

vector和array类似的地方就是它们都是同一对象类型的集合。不同点是array是固定长度的。iterator之于vector就如同指针之于array。

使用指针的一个重要原因是vector不能提供所需的访问速度。

数组类型不能是引用（reference）

4.1 Array

关于Array初始化：

l         使用class默认的构造函数初始化每个单元。

l         Character Array即可以用字符数组来初始化也可以用string来初始化，注意如果用string，那么自动在末尾追加了null作为结束符，这样数组的长度+1.

下标操作时，要使用数据类型是：size_t,就像在vector中使用size_type。

4.2 Pointers

什么是指针

Pointers are iterators for arrays.指针是用于数组的迭代器。

pointer holds the address of another object:。具体来说，指针保存的是另一个对象的地址。

*sp里面*代表sp是一个指针。

Best practice：指针初始化时，如果不能指向具体的地址，就设置为0，这样在程序中就可以检测出指针没有指向一个对象（object）。

指针初始化和赋值操作的约束

指针初始化和赋值

只有4类值可以初始化指针和指针赋值：

1.值为0的常量表达式。不能把任何的int赋值给指针，即使这个int的值是0，但是可以把值是0的const 或者数值0赋值给指针。NULL定义为0，所以也可以使用。NULL叫做预处理变量。

2.类型匹配的对象的地址

3.另一对象末的下一地址

4.同类型的其它有效的指针

void*指针，这是一个特殊类型的指针，它能够是任何对象的地址。它就是说明它的值是一个指针，但是指针所指向的对象的类型是不可知的。

因此void*指针只能执行通用的操作：

l         指针比较

l         传递给function或者作为function的返回值。

l         赋值给另一个void*指针

Operations on Pointer（指针操作）

注意*在这里是一个operator。dereference a pointer。解引用操作（dereference operator）返回指定对象的左值lvalue。因此可以进行赋值操作。

引用和指针的区别：

1.        引用总是指向对象object。引用必须初始化，但指针是可以仅仅定义，而无需初始化的。

2.        赋值：引用的赋值会改变引用所绑定的对象的值；引用是不能重新绑定新的对象的。一旦初始化，引用总是指向同一个对象。

引用：

指针：

指向指针的指针**ppi，代码：

对ppi解引用2次，就可以得到ival的值了。

1.        使用指针访问数组单元

当使用数组的名字时，这个名字就自动转换为指向数组第一个单元的指针。

指针的算数运算会产生一个新指针。

两指针相减得到的数据类型是ptrdiff_t。它是一个

如何获得一个数组的结尾？

p2就是指向了数组的结尾。

指向const对象的指针和const指针

1.        指向const对象的指针

如果指针指向的是一个const对象，那么肯定不希望它能够修改这个const对象的值。那么这样的指针如何定义？

对于这个定义的理解是这样子的：

A.        这里的限定词（qualifier）-const是限定cptr指向的数据类型必须是const double，而不是限定cptr本身。

B.        cptr本身不是const

C.       不能做的是用cptr去修改它指向的对象的值

但是也可以把指向const对象的指针赋值为非const对象的地址。（A pointer to a const object can be assigned the address of a nonconst object）

不过我想，这只不过是代码上的文字游戏而已，如果程序这样写，也许会死人的。混乱！

这种指针的用途是作为方法的参数，这可以保证这个参数不会在方法中被修改。（哎，要不怎么说是大师呢，佩服！）

2.        const指针

const指针的值是不可以修改的，但是const指针指向的对象的值是可以修改的。

3.        指针和typedef

复习：

typedef 可以用来定义类型的同义词。wages就是double的同义词

（以下的这段很饶人啊）

第一绕：pstring类型是指向string类型的指针类型。

第二绕：const是用来修饰pstring类型的，const pstring就是const的string指针

第三绕：这不存在简单的文字替换的游戏：const pstring cstr;等于const string* cstr;所以就是指向const string的指针。错误！

4.3 C风格字符串

不建议在C++中使用C风格的字符串，原因是它有“many many”的安全问题。

1.        什么是C风格的字符串？

它不是一种类型，而是以空字符 null 结束的字符数组。

定义：

遍历字符串

2.        字符串函数

C标准库提供了一系列的字符串函数，但是这些函数都不检查参数的合法性（限制条件）。这就是Lippman不建议在C++中使用C风格的字符串的原因。

主要的限制：

1.        传递给这些标准库函数的指针必须是非空的。

2.        每个指针必须是以null结尾的。

3.        数组的长度要足够大

strlen(s)，返回的是s的长度，但是这里并不包含null，因此数组的实际长度是strlen(s)+1。

3.        使用动态数组

为什么要使用动态数组？

通常是因为在编译时无法知道数组的维数，所以才需要动态创建该数组。

如果是普通的定义数组，以上的定义是根本无法实现的，因为在编译期是不能确定数组的大小的。只能这样定义：

因此就可以得出结论：动态数组主要是用于当数组的尺寸不能在编译期确定的情况。

数组释放：

4.        疑问代码（P139）：

我认为在const size_t len = strlen(pc +1);  这行存在笔误，应该是

const size_t len = strlen(pc )+1;

否则copy后得到的结果pc2不是C风格的字符串，因为最后一个单元的内容是’g’而不是null。

4.4多维数组 Multidimensioned Arrays

C++实际是没有多维数组的，

int ia[3][4]

可以理解为数字大小是3，每个单元element又是一个大小是4的int数组。或者叫做3行3列。

1.        指针和多维数组

这段代码就如同“回”字的N多种写法一样：

打印结果是一样的，都是‘8’。

2.        以下2种定义的区别（圆括号是必不可少的）

指针数组：

如果从内向外阅读 ip 的声明，则可理解为：*ip 是 int[4] 类型——即 ip 是一个指向含有 4 个元素的数组的指针。

进一步的理解：

刚开始，我觉得应该写成ip=ia[2];结果得到报错信息：

因为ia[2]就是一个数组啊，再想如果这样写ip=ia[2];这就相当于

当然是错误的。

Library Types

3.1 Namespace

为什么要用namespace？

namespace就是为了区分重名的类。

名字空间的主要作用是解决标识符冲突问题。 
 比如C++   Standard   Library就是在名字空间std下，如果没有名字空间，其中的list就非常可能和自己定义的一些标识符重复。 
 两种使用方法： 
  1、  std::list<int>   myIntList;  
  2、在cpp文件的开头加上using   namespace   std;  
    这样在文件中就可以直接使用list<int>   myIntList了。

3.2 string

初始化：

读入string对象，有两种方式

1.        使用读入操作符cin

2.        使用getline()函数

输入操作符会忽略开头的空格，直至遇到第一个空白字符（leading space）就停止读入。和输入操作符不一样的是，getline() 并不忽略行开头的换行符。

String.size()返回的不是int或者unsigned数据类型，而是一个和机器无关的string::size_type，虽然不知道string::size_type的具体类型，但可以肯定的是它一定是unsigned类型。

更加关键的是st1 = st2;的执行过程：

1实际上是把原来分配给st1的空间删除掉，

2再分配新的空间，copy过来st2的内容。

3.3 vector

vector中包含的必须是统一的数据类型。

vector不是一种类型，这是一个模板template。

vector并不需要预先分配内存空间。

初始化：

vector的大小

tip：

如果要取得vector的大小，要定义数据类型是vector<int>::size_type。这和Java有很大的不同，随意性很小了。

3.4 Introducing Iterators

每个容器类型都会定义自己的迭代类型。

vector<int>对应的迭代类型就是vector<int>::iterator。

每个容器类型中都会包含一个成员（member），这个成员是容器的迭代器的实际类型。

只要一种类型实现了迭代器所定义的所有操作，那么这种类型就可以称为是一个迭代器类型（iterator type）。因此迭代器类型有很多种。

每种容器类型都定义了对应的iterator类型，但是并不是所有的容器类型都定义下表索引的方式。因此应使用容器访问容器的单元。

访问当前单元的值要使用解引用操作符*，解引用操作符返回的是一个值。

const_iterator

我刚开始不是很明白为什么要定义const_iterator类型，后来看了下面的代码 – 以只读模式遍历一个vector，就明白了

遍历：++it //错误！

所以要这样定义：

vector<int>::const_iterator it

遍历：++it // ok

任何操作改变了vector的size，那么现有的iterator都会失效。就是说，

先执行vector<int>::iterator iter = ivec.begin()

然后追加element：ivec.add(9);

那么前面的iter就失效了。

3.5 bitset

首先明确这和vector一样，都是模板template。bitset只有大小的不同。

bitset<32> bitvec; // 32 bits, all zero

bitset初始化

从构造函数可以看出，bitset是指定长度的，这和vector有点不一样。

从string初始化bitset，要注意的是string和bitset的顺序是相反的：就是说从右向左读string的bit。

例如：

那么bitvec4的第2位，第3位才是1.即使是对string的截串处理也应保证从右向左读。