在C++中我们应该少用指针，多用引用，原因请大家自行搜索。在传递数组的时候我们需要格外注意，先让我们看一个简单的范例。

// PassArray.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>

using namespace std;

template <typename T>
void Func1(T, T);
template <typename T>
void Func2(T&, T&);
void Func3(int (&)[10], int (&)[12]);

int _tmain(int argc, _TCHAR* argv[])
{
    int a[10], b[12];

    Func1(a, b);
    Func2(a, b);
    Func3(a, b);

    return 0;
}

template <typename T>
void Func1(T, T)
{
    cout<<"Func1.invoked!"<<endl;
}
template <typename T>
void Func2(T&, T&)
{
    cout<<"Func2.invoked!"<<endl;
}
void Func3(int (&m)[10], int (&n)[12])
{
    cout<<"Func3.invoked!"<<endl;
}

首先这个范例无法编译通过：

原因就出在类型推断上。根据定义，Func2的类型必须是T&，也就是说传递实参的时候，两个形参必须是相同的，而这一点在模板编程中就会由编译器来负责推断。

Func1：

调用Func1(a, b)则推断的类型分别是Func1(int*, int*)，调用函数将会自动将数组的首地址指针作为实参进行传递，因此类型推断两形参相同，编译通过！

Func2：

调用Func2(a, b)因为我们希望按引用的方式进行实参传递，因此需要遵循这样的规律：

（P208）如果形参是数组的引用，编译器将不会将数组实参转化为指针，而是传递数组引用的本身。在这种情况下，数组大小成为形参和实参类型的一部分。

所以推断类型分别是Func2(int (&)[10], int (&)[12])，因为int (&)[10] != int (&)[12]，所以与T == T相悖！自然也就编译不过了！

Func3：

该函数是Func2的一个静态表示，通过上面的解释应该很容易理解这个代码了。

51、static成员函数

因为static成员不是任何对象的组成部分，所以static成员函数不能被声明为const。毕竟，将成员函数声明为const就是承诺不会修改该函数所属的对象。最后，static成员函数也不能被声明为虚函数。

52、特殊的整型const static成员（P401）

const static数据成员在类的定义体中初始化时，该数据成员仍必须在类的定义体之外进行定义。

但在gcc和MS vc++编译器下似乎均不需要再次定义，也就是题设的“必须”二字在此失效。

53、操作符重载（P435）

下面是一些指导原则，有助于决定将操作符设置为类成员还是普通非成员函数

• 赋值（=）、下标（[]）、调用（()）和成员访问箭头（->）等操作符必须定义为成员，将这些操作符定义为非成员函数将在编译时标记为错误。
• 像赋值一样，复合赋值操作符通常应定义为类的成员。与赋值不同的是，不一定非得这样做，如果定义非成员复合赋值操作符，不会出现编译错误。
• 改变对象状态或与给定类型紧密联系的其他一些操作符，如自增、自减和解引用，通常应定义为类成员。
• 对称的操作符，如算术操作符、相等操作符、关系操作符和位操作符，最好定义为普通非成员函数。

54、区别操作符的前缀和后缀形式（P447）

同时定义前缀式操作符和后缀式操作符存在一个问题：它们的形参数目和类型相同，普通重载不能区别所定义的是前缀式操作符还是后缀式操作符。

为解决这一问题，后缀式操作符函数接受一个额外的（即，无用的）int型形参。使用后缀操作符时，编译器提供0作为这个形参的实参。尽管我们的前缀式操作符函数可以使用这个额外的形参，但通常不应该这样做。那个形参不是后缀式操作符的正常工作所需要的，它的唯一目的是使后缀函数与前缀函数区别开来。

55、显式调用前缀式操作符

56、函数对象（P450）

尽管absObj是一个对象而不是函数，我们仍然可以“调用”该对象，效果是运行由absObj对象定义的重载调用操作符，该操作符接受一个int值并返回它的绝对值。

函数对象经常用作通用算法的实参。（详见P450）

57、函数对象的函数适配器（P453）

标准库提供了一组函数适配器（function adapter），用于特化和扩展一元和二元函数对象。函数适配器分为如下两类：

（1）绑定器（binder），是一种函数适配器，它通过将一个操作数绑定到给定值而将二元函数对象转换为一元函数对象。（bind1st和bind2nd 更多）

（2）求反器（negator），是一种函数适配器，它将谓词函数对象的真值求反。（not1和not2 更多）

58、转换操作符（P455）

转换为什么有用？（详见P454）

转换函数采用如下通用形式：

operator type();

这里，type表示内置类型名、类类型名或由类型别名所定义的名字。对任何可作为函数返回类型的类型（除了void之外）都可以定义转换函数。一般而言，不允许转换为数组或函数类型，转换为指针（数据或函数指针）以及引用类型是可以的。

转换函数必须是成员函数，不能指定返回类型，并且形参表必须为空。

转换函数一般不应该改变被转换的对象。因此，转换操作符通常应定义为const成员。

59、只能应用一个类类型转换

类类型转换之后不能再跟另一个类类型转换。如果需要多个类类型转换，则代码将出错。

假设有Integral=>SmallInt=>int，但是如果有一个函数cal(int)，那么对于SmallInt si，可以使用cal(si)，但对于Integral intVal;则不能使用cal(intVal)。语言只允许一次类类型转换，所以该调用出错。

60、virtual与其他成员函数（P479）

C++中的函数调用默认不使用动态绑定。要触发动态绑定，必须满足两个条件：第一，只有指定为虚函数的成员函数才能进行动态绑定，成员函数默认为非虚函数，非虚函数不进行动态绑定；第二，必须通过基类类型的引用或指针进行函数调用。

基类类型引用和指针的关键点在于静态类型（static type，在编译时可知的引用类型或指针类型）和动态类型（dynamic type，指针或引用所绑定的对象的类型，这是仅在运行时可知的）可能不同。

41、vector、list、deque的性能初窥

int large_size = 10000000;

cout_current_time("start init vector!\t");
vector<string> svec1(large_size, "Hello");
vector<string> svec2(large_size, "Hi");
cout_current_time("end init vector!\t");

cout_current_time("start init list!\t");
list<string> slist1(large_size, "Hello");
list<string> slist2(large_size, "Hi");
cout_current_time("end init list!\t");

cout_current_time("start init deque!\t");
deque<string> sdeq1(large_size, "Hello");
deque<string> sdeq2(large_size, "Hi");
cout_current_time("end init deque!\t");

用事实说话最有说服力：

start init vector!    current time : 5:5:52
end init vector!    current time : 5:5:55
start init list!    current time : 5:5:55
end init list!    current time : 5:6:14
start init deque!    current time : 5:6:14
end init deque!    current time : 5:6:26

可以看出大致时间比例为3/19/12。虽然不足以佐证它们的性能差距，但vector的常用似乎有了更充分的理由。

这里使用了一个简单的时间函数大致如下：

#include <time.h>

typedef struct tm * time_type;
time_type get_current_time(void) {
    time_t t;

    t = time(NULL);
    return localtime(&t);
}

42、容器自增长（P286）

每种实现都要求遵循以下原则：确保push_back操作高效地在vector中添加元素。从技术上来说，在原来为空的vector容器上n次调用push_back函数，从而创建拥有n个元素的vector容器，其执行时间永远不能超过n的常量倍。

43、类定义中为何不能具有自身的数据成员（P375）

因为只有当类定义体完成后才能定义类，因此类不能具有自身类型的数据成员。然而，只要类名一出现就可以认为该类已声明。因此，类的数据成员可以是指向自身类型的指针或引用：

44、两种引用类类型的方法（P376）

Sales_item item1; //default initialized object of type Sales_item

class Sales_item item1; //equivalent definition of item1

两种引用类类型的方法是等价的。第二种方法是从C继承而来的，在C++中仍然有效。第一种更为简练，由C++语言引入，使得类类型更容易使用。

45、为什么类的定义以分号结束（P376）

分号是必须的，因为在类定义之后可以接一个对象定义列表。定义必须以分号结束：

class Sales_item {/* … */};

class Sales_item {/* … */} accum, trans;

46、形参表和函数体处于类作用域中，函数返回类型不一定在类作用域中

在定义于类外部的成员函数中，形参表和成员函数体都出现在成员名之后。这些都是在类作用域中定义，所以可以不用限定而引用其他成员。因为形参表是在Screen类作用域内，所以不必知名我们想要的是Screen::index。

如果返回类型使用由类定义的类型，则必须使用完全限定名。

#include "stdafx.h"
#include <iostream>

class MyClass
{
public :
    typedef int index_t;
    index_t twice(index_t in);
};

MyClass::index_t MyClass ::twice(index_t in)
{
    return in * 2;
}

int _tmain(int argc, _TCHAR* argv[])
{
    using namespace std; 
    
    MyClass obj;
    MyClass::index_t x, y;
    
    x = 10;
    y = obj.twice(x);

    cout<<"x = "<<x<<"; y = "<<y<<";"<<endl;

    return 0;
}

47、构造函数初始化式（P387）

与任意的成员函数一样，构造函数可以定义在类的内部或外部。构造函数初始化式只在构造函数的定义中而不是声明中指定。

构造函数初始化列表难以理解的一个原因在于，省略初始化列表并在构造函数的函数体内对数据成员赋值是合法的。

在构造函数初始化列表中没有显式提及的每个成员，使用与初始化变量相同的规则来进行初始化。运行该类型的默认构造函数，来初始化类类型的数据成员。内置或复合类型的成员的初始值依赖于对象的作用域：在局部作用域中这些成员不被初始化，而在全局作用域中它们被初始化为0。

如果那个类没有默认构造函数，则编译器尝试使用默认构造函数将会失败。在这种情况下，为了初始化数据成员，必须提供初始化式。

对于这样的成员，在构造函数函数体中对它们赋值不起作用。没有默认构造函数的类类型成员，以及const或引用类型的成员，不管是哪种类型，都必须在构造函数初始化列表中进行初始化。

因为内置类型的成员不进行隐式初始化，所以对这些成员是进行初始化还是赋值似乎都无关紧要。除了两个例外，对非类类型的数据成员进行赋值或使用初始化式在结果和性能上都是等价的。

48、成员初始化的次序

构造函数初始化列表仅指定用于初始化成员的值，并不指定这些初始化执行的次序。成员被初始化的次序就是定义成员的次序。

在这种情况下，构造函数初始化列表看起来似乎是用val初始化j，然后再用j来初始化i。然而i首先被初始化。这个初始化列表的效果是用尚未初始化的j值来初始化i！

49、使用默认构造函数（P393）

常犯的一个错误是采用以下方式声明一个用默认构造函数初始化的对象：

Sales_item myobj();

正确的方式应该是去掉相应的括号：

Sales_item myobj;

或者

Sales_item myobj = Sales_item();

50、显式或隐式初始化

#include "stdafx.h"
#include <iostream>
using namespace std; 
class MyClass
{
public :
    typedef int index_t;
    bool same_object(MyClass obj);

public :
    MyClass(int default_index = 5)
        :default_index(default_index),
        m_name("default_name"){}
    MyClass::MyClass(std::string name);

public :
    int default_index;
    std::string m_name;
};

MyClass::MyClass(std::string name)
        :default_index(0), m_name(name){}

bool MyClass::same_object(MyClass obj)
{
    cout<<"m_name = "<<m_name.c_str()<<endl;
    cout<<"obj.m_name = "<<obj.m_name.c_str()<<endl;
    return strcmp(obj.m_name.c_str(), m_name.c_str()) == 0;
}

int _tmain(int argc, _TCHAR* argv[])
{    
    MyClass obj;

    cout<<"explicit : "<<obj.same_object(MyClass("default_name"))<<endl;
    cout<<"implicit : "<<obj.same_object(string("default_name"))<<endl;

    return 0;
}

因为具有以std::string为形参的构造函数，因此在调用需要MyClass对象的same_object成员函数时，会自动隐式调用该构造函数构建MyClass对象，用于操作。但生成的MyClass对象是临时对象，在same_object函数调用完成后销毁。如果为了避免产生隐式转换可以使用explicit关键字来抑制由构造函数定义的隐式转换：

31、动态空间的释放（P119）

动态空间的释放使用delete [] pia;（其中pia为指向动态分配的数组的第一个元素的指针）。在关键字delete和指针之间的方括号对是必不可少的：它告诉编译器该指针指向的是自由存储区中的数组，而并非单个对象。

如果遗漏了空方括号对，这是一个编译器无法发现的错误，将导致程序在运行时出错。

使用std::string后则会自动进行释放，无需delete！

32、c_str返回的数组并不保证一定是有效的……

std::string st1("I am a string object!");
//error C2440: “初始化”: 无法从“const char *”转换为“char *”
//char *str = st1.c_str();
const char *cstr = st1.c_str();
std::cout<<cstr<<std::endl;

c_str返回的数组并不保证一定是有效的，接下来对st1的操作有可能会改变st1的值，使刚才返回的数组失效。如程序需要持续访问该数据，则应该复制c_str函数返回的数组。

33、指向函数的指针

详见《指向函数的指针的一点理解》

34、容器初始化

在大多数的程序中，使用默认构造函数能达到最佳运行时性能，并且使容器更容易使用。

35、容器头文件

#include <vector>

#include <list>

#include <deque> //双端队列“double-ended queue”，发音为“deck”

标准库定义了以上三种顺序容器类型。

36、容器的容器

必须用空格隔开两个相邻的>符号，以示这是两个分开的符号，否则，系统会认为>>是单个符号，为右移操作符，并导致编译时错误。

int m, n;
m = 5;
n = 3;

cout << "Print a line!" << endl;
vector<string> lines(n, " I_am_a_PC_! ");
for (vector<string>::iterator siter = lines.begin(); siter != lines.end(); ++siter) {
    cout << *siter;
}
cout << endl;

cout << "Print a paragraph!" << endl;
vector<vector<string> > paragraph(m, lines);
for (vector<vector<string> >::iterator piter = paragraph.begin(); piter
        != paragraph.end(); ++piter) {
    for (vector<string>::iterator siter = (*piter).begin(); siter
            != (*piter).end(); ++siter) {
        cout << *siter << ends;
    }
    cout << endl;
}

37、迭代器范围（P269）

C++定义的容器类型中，只有vector和deque容器提供下面两种重要的运算集合：迭代器算术运算，以及使用除了==和!=之外的关系操作符来比较两个迭代器（==和!=这两种关系运算适用于所有容器）。

list容器的迭代器既不支持算术运算（减法或加法），也不支持关系运算（<=,<,>=,>）它只提供前置和后置的自增、自减以及相同（不等）运算。

38、容器元素都是副本

在容器中添加元素时，系统是将元素值复制到容器里的。类似地，使用一段元素初始化新容器时，新容器存放的是原始元素的副本。被复制的原始值与新容器中的元素各不相关，此后容器内元素值发生变化时，被复制的原值不会受到影响，反之亦然。

39、下标操作和.at(n)的区别

vector<string> svec; //empty vector;

cout << svec[0]; //run-time error:There are no elements in svec!

cout << svec.at(0); //throws out_of_range exception

40、容器的赋值（P283）

assign操作首先删除容器中所有的元素，然后将其参数所指定的新元素插入到该容器中。与复制容器元素的构造函数一样，如果两个容器类型相同，其元素类型也相同，就可以使用赋值操作符（=）将一个容器赋值给另一个容器。如果在不同（或相同）类型的容器内，元素类型不相同但是相互兼容，则其赋值运算必须使用assign函数。例如，可通过assign操作实现将vector容器中一段char*类型的元素赋给string类型的list容器。

由于assign操作首先删除容器中原来存储的所有元素，因此，传递给assign函数的迭代器不能指向调用该函数的容器内的元素。

21、vector的动态增长优于预先分配内存。

使用vector的时候最好动态地添加元素。它不同于C和Java或其他语言的数据类型，为了达到连续性，更有效的方法是先初始化一个空vector对象，然后再动态添加元素，而不是预先分配内存。

22、vector值初始化

内置->0

有默认构造->调用默认构造

无默认构造，有其他构造->程序员手动提供初始值

无默认构造，也无其他构造->标准库产生一个带初值的对象

23、数组下标的类型

C++中，数组下标的正确类型是size_t而不是int，size_t是一个与机器相关的unsigned类型。

24、在声明指针的时候，可以用空格将符号*与其后的标识符分隔开来，string *ps与string* ps都是可以的，但后者容易产生误解，如：

string* ps1,ps2;     //ps1是指针，而ps2是一个string对象

也就是说，人们可能误把string和string*当作两个类型，或者说string*被当作一种新类型来看待，但这是错的！

25、一个有效的指针必然是以下三种状态之一：

1. 保存特定的对象的地址；
2. 指向某个对象后面的另一对象；
3. 或者是0值。表明它不指向任何对象。

其中int *pi=0;与int *pi;是不同的。前者是初始化指针指向0地址的对象（即为NULL）（pi initialized to address to no object），后者却是未初始化的（ok, but dangerous, pi is uninitialized）。

编译器可以检测出0值的指针，程序可判断该指针并未指向一个对象，而未初始化的指针的使用标准并未定义，对大多数编译器来说，如果使用未初始化的指针会将指针中存放的不确定值视为地址，然后操纵该内存地址中存放的位内容，使用未初始化的指针相当于操纵这个不确定的地址中存储的基础数据，因此对未初始化的指针进行解引用时，通常会导致程序崩溃。

26、void*指针

void*指针只支持几种有限的操作：

1. 与另一个指针进行比较；
2. 向函数传递void*指针或从函数返回void*指针；
3. 给另一个void*指针赋值。

不允许使用void*指针操纵它所指向的对象。

27、指针和引用的比较（P105）

虽然使用引用（reference）和指针都可间接访问另一个值，但它们之间有两个重要区别。第一个区别在于引用总是指向某个对象：定义引用时没有初始化是错误的。第二个重要区别则是赋值行为的差异：给引用赋值修改的是该引用所关联的对象的值，而并不是使引用与另一个对象关联。引用一经初始化，就始终指向同一个特定对象（这就是为什么引用必须在定义时初始化的原因）。

28、指针与typedef（P112）

const放在类型前和放在类型后都可以表示同样的意思：

const string s1;
string const s2;

s1和s2均表示常量字符串对象。

但因此就导致了下面的句子可能产生误解：

typedef string *pstring;
const pstring cstr;

容易错把typedef当成文本扩展而产生下面的理解：

const string *cstr; //这并非上面例子的正确意思！（错误）

应该从声明的句子看，也就是说只看const pstring cstr;，在这里pstring是一种指针类型，const修饰的是这个类型，因此正确的理解应该是：

string *const cstr;

而const pstring cstr;其实可以表示为pstring const cstr;，这样的写法则不容易产生误解。从右向左阅读的意思就是：cstr是const pstring类型，即指向string对象的const指针。

29、创建动态数组（注意点见代码注释）

const char *cp1 = "some value";
char *cp2 = "other value";

int *piArray1 = new int[10];    //内置类型没有初始化
int *piArray2 = new int[10]();    //内置类型需要加空圆括号，对数组元素进行初始化
std::string *psArray1 = new std::string[10];    //默认构造函数初始化

std::cout<<"----------"<<std::endl
    <<"*cp1\t\t:"<<*cp1<<std::endl
    <<"*cp2\t\t:"<<*cp2<<std::endl
    <<"*piArray1\t:"<<*piArray1<<std::endl
    <<"*piArray2\t:"<<*piArray2<<std::endl
    <<"*psArray1\t:"<<*psArray1<<std::endl
    <<"----------"<<std::endl;

但是下面的结果却与概念上的不同：

////Visual Studio & MS VC++
//----------                   
//*cp1            :s
//*cp2            :o
//*piArray1       :-842150451
//*piArray2       :0
//*psArray1       :
//----------
////Eclipse&G++
//----------
//*cp1        :s
//*cp2        :o
//*piArray1    :4064608
//*piArray2    :4064560
//*psArray1    :
//----------

看来不同的编译器对此的定义还是有所不同，注意看*piArray2的值，按照说明应该是初始化为0，但这里却仍然表现出与*piArray1一样的值，说明并没有发生初始化。

对于动态分配的数组，其元素只能初始化为元素类型的默认值，而不能像数组变量一样，用初始化列表为数组元素提供各不相同的初值。

30、const对象的动态数组

//P118
//error:uninitialized const array
const int *pciArray1 = new const int[10];
//ok:value-initialized const array
const int *pciArray2 = new const int[10]();
std::cout<<*pciArray1<<std::endl;
std::cout<<*pciArray2<<std::endl;

上面的示例的注释来自书中，但在VC++编译器和G++编译器下却不同，具体表现为：

• VC++：编译正确，第一句输出随机地址的值，第二句输出初始化的0（其中按照“标准”第一种因为未向const变量初始化，应该无法通过编译，但这里可以）
• G++：编译错误，第一句的错误信息为“uninitialized const in `new' of `const int'”，但第二句按照标准应该输出0的，这里却输出了随机地址的值。

看来两个编译器对这一问题的看法不太一致。

11、枚举

//enum     
enum HttpVerbs { Head, Post, Get, Delete }; 
    
HttpVerbs current_verbs = Post;     
std::cout<<"Current Verbs = "<<current_verbs<<std::endl;
     










//error C2440: “=”: 无法从“int”转换为“HttpVerbs”     
//current_verbs = 3;
     

current_verbs = (HttpVerbs)2;     
std::cout<<"Current Verbs = "<<current_verbs<<std::endl;
     
HttpVerbs copy_verbs = current_verbs;     
std::cout<<"Copy Verbs = "<<copy_verbs<<std::endl;
     
HttpVerbs future_verbs = (HttpVerbs)((current_verbs + 1)%sizeof(HttpVerbs));     
std::cout<<"Future Verbs = "<<future_verbs<<std::endl;
     
std::cout<<"HttpVerbs Size![by sizeof(HttpVerbs)] = "<<sizeof(HttpVerbs)<<std::endl;

输出：

Current Verbs = 1
Current Verbs = 2
Copy Verbs = 2
Future Verbs = 3
HttpVerbs Size![by sizeof(HttpVerbs)] = 4

12、类，成员变量初始化

定义变量和定义数据成员存在着非常重要的区别：一般不能把类成员的初始化作为其定义的一部分。当定义数据成员时，只能指定该数据成员的名字和类型。类不是在类定义里定义数据成员时初始化数据成员，而是通过成为构造函数的特殊成员函数控制初始化。

class MyClass1
{
public:
     int GetMyValue();
     void SetMyValue(int value);
private:
     //error C2864: “MyClass1::myValue”: 只有静态常量整型数据成员才可以在类中初始化
     int myValue = 3;       //只需修改为int myValue;即可
};

13、struct关键字

C++支持另一个关键字struct，它也可以定义类类型。struct关键字是从C语言中继承过来的。

如果使用class关键字来定义类，那么定义在第一个访问标号前的任何成员都隐式指定为private；如果使用struct关键字，那么这些成员都是public，除非有其他特殊的声明，如添加了private才为private，否则都是public，因此没必要添加public关键字。

用class和struct关键字定义类的唯一差别在于默认访问级别：默认情况下，struct的成员为public，而class的成员为private。

14、预编译头文件

一、什么是预编译头文件?
预编译头文件物理上与通常的的.obj文件是一样的，但编译入预编译头的.h,.c,.cpp文件在整个编译过程中，只编译一次，如预编译头所涉及的部分不发生改变的话，在随后的编译过程中此部分不重新进行编译。进而大大提高编译速度，并便于对头文件进行管理，也有助于杜绝重复包含问题。

VC++程序一般包含的头文件都比较复杂，如果每次都逐行分析可能会花很多时间，所以VC++默认设置是第一次编译时分析所有头文件，生成.pch文件，这个文件很大，但以后每次编译时就可以节省很多时间。如果删除了这个文件，下次编译时VC++会自动生成它。

二、什么时候使用预编译头?
当大多.c或.cpp文件都需要相同的头文件时。
当某些代码被大量重复使用时。
当导入某些不同库都有实现的函数，并产生混乱时。

15 、在头文件中必须总是使用完全限定的标准库名字。

因为预处理器会将头文件复制到使用它的任何地方，两种可能，一种是如果在头文件中使用using，会使相关代码不论是否需要该using都必将放置一个using，另一种是，假设有另一个库可能也包含了相应的方法如有方法std::cout以及my::cout，如果使用了using，有可能导致被引入的程序偏离原本的使用意图，或者导致编译错误。

16、字符串字面值和标准库string不是同一种类型

因为历史原因以及为了与C语言兼容，字符串字面值与标准库string类型不是同一种类型。这一点很容易引起混乱，编程时一定要注意区分字符串字面值和string数据类型的使用，这很重要。

17、getline函数输入的时候丢弃末尾的换行符，并将整行返回，而且不丢弃第一个换行符，也就是即便你一开始就输入了换行符，它仍然会返回，只不过返回的是一个空字符串而已。

编写程序实现从标准输入每次读取一行文本。然后改写程序，每次读入一个单词!

//std::cout<<"getline：<<std::endl;
WriteLine("getLine");
WriteLine("P72 编);
using std::string;

WriteLine("每(输"NEXT\"进");
string str;
while(std::getline(std::cin, str))
{
    if(str == "NEXT")
        break;
    std::cout<<str<<std::endl;
}

WriteLine("每输"NEXT\"进");
while(std::getline(std::cin, str))
{
    if(str == "NEXT")
        break;
    //从第0个开始查找空白
    static const std::basic_string<char>::size_type npos = (std::basic_string<char>::size_type)-1;
    std::basic_string<char>::size_type firstIndexOfEmpty = str.find_first_of(" ", 0);
    if(firstIndexOfEmpty != npos)
        std::cout<<str.substr(0, firstIndexOfEmpty)<<std::endl;
    else
        std::cout<<str<<endl;
}

其中WriteLine函数：

void WriteLine(std::string str)
{
    std::cout<<str<<std::endl;
}

18、std::string对象的加法

如果一串字符串和string对象混合相加，则要求+操作符左右操作数必须至少有一个是string类型的。

推论：一串字符串和string对象混合相加，前两个操作数中至少有一个是string对象。

std::string str2 = str1 + "this" + " that" + " those";
std::cout << str2 << std::endl;
//error C2110: “+”: 不能添加两个指针
std::string str3 = "this" + " that" + str1 + " those";
std::cout << str3 << std::endl;

19、C标准库头文件和C++版本

C++标准库也包括C标准库，命名上则在C标准库的名字前加一个c并省去后缀.h，比如C标准库中的ctype.h，在C++中就有相应的标准库cctype（注意没有.h）。C++和C标准库文件的内容是一样的，只是采用了更适合C++的形式。而且通常cname头文件中定义的名字都定义在命名空间std内，而.h版本的名字却不是这样。

20、关于中文编码的相关问题

我们知道大部分的编译器以及解决方案都由外国人发明创造，特别是美国人。因此很多程序默认不支持中文。虽然随着Unicode的普及这部分问题得到了很大的改善（比如C#就可以完美地支持中文），但是类似C++这样的语言，仍然面临着中文编码的问题。关于编码，有一篇值得推荐的文章：地址1（备用地址）下载后打印（docx，50.7KB）查找更多

标识符不能包含两个连续的下划线，也不能以下划线开头后面紧跟一个大写字母。有些标识符（在函数外定义的标识符）不能以下划线开头。

但是在G++编译器和VC编译器下，二者均可正确编译！

2、跨平台编译程序！

这里不是要讲解如何跨平台编译程序，也不是告诉你如何更好地编写通用平台的程序规则，那可能涉及到很多的宏定义以及硬件相关特性。这里仅为使用示例代码提供一种精简的方式。

用Eclipse+MinGW的方式默认会很精简，所以把它当作一种目标！

用Visual Studio 2008创建的程序会让你引入预编译头stdafx.h（这通常发生在使用Visual Studio创建Win32控制台应用程序，并直接点击“完成”后），这将导致你无法将在Eclipse上编写的程序直接运行在Visual Studio上。这时你应该通过修改项目属性来获得这种精简的方式：（选择项目，右键属性，选择配置属性->C/C++->预编译头->创建/使用预编译头，选择“不使用预编译头”->“确定”后再次编译即可！）

3、变量命名习题

//测试变量命名！
//error C2632: “int”后面的“double”非法
//int double = 3.14159;
//-------------------------------------------------
char _='a';
std::cout<<_<<std::endl;
//-------------------------------------------------
//warning C4091: “”: 没有声明变量时忽略“bool”的左侧
//error C2059: 语法错误: “-”
//bool catch-22;
//-------------------------------------------------
//error C2059: 语法错误: “数字上的错误后缀”
//char 1_or_2 = '1';
//-------------------------------------------------
float Float=3.14f;
std::cout<<Float<<std::endl;

4、在C++中，“初始化不是赋值”

初始化指创建变量并给它赋初始值，而赋值则是擦除对象的当前值并用新值代替。

int ival(1024); //直接初始化
int ival = 1024; //复制初始化

直接初始化语法更灵活，效率更高！

对内置类型来说，复制初始化和直接初始化几乎没有差别。

对类类型来说，有些初始化仅能用直接初始化完成。要想理解其中缘由，需要初步了解类是如何控制初始化的。

例如：

也可以通过一个计数器和一个字符初始化string对象。这样创建的对象包含重复多次的指定字符，重复次数由计数器指定：

std::string all_nines(10, ‘9’); //all_nines = “9999999999”;

本例中，初始化all_nines的唯一方法是直接初始化。有多个初始化式时不能使用复制初始化。（V注：这里的初始化式即为构造函数的多个重载；这里所谓的“不能使用”应该是“功能有所不及”的意思！）

5、变量初始化规则

使用未初始化的变量经常导致错误，而且十分隐蔽。问题出在未初始化的变量事实上都有一个值。编译器把该变量放到内存中的某个位置，而把这个位置的无论哪种位模式都当成是变量初始的状态。当被解释成整型值时，任何位模式都是合法的值——虽然这个值不可能是程序员想要的。因为这个值合法，所以使用它也不可能导致程序崩溃。可能的结果是导致程序错误执行和/或错误计算。

//在Eclipse中运行没有出现错误！
//在Visual Studio中运行出现运行时错误！
int ival;    //没有初始化！
std::cout<<ival<<std::endl;

6、声明和定义

为了能让多个文件访问相同的变量，C++区分了声明和定义。简单地说就是可以用extern关键字来声明，任何有分配内存行为的声明都是定义。定义也是声明。声明：标明变量的类型和名字；定义：为变量分配存储空间，还可以为变量指定初始值。

举例说明：

extern double pi; //声明
double pi; //定义，声明了pi同时定义了pi
extern double pi = 3.14159; //定义，因为它为pi分配了初值。只有当该extern语句
     位于函数外部的时候才允许使用初始化式，否则将导致编译错误。

7、变量的隐藏：

std::string s1 = "I am a std::string!";
std::cout<<s1<<std::endl;
for(int s1=3; s1!=0; --s1)
std::cout<<"I am a number(int):"<<s1<<std::endl;

提示：在Visual Studio 2008中使用std::string定义一个变量，再通过std::cout将其输出，将会得到“error C2679: 二进制“<<”: 没有找到接受“std::string”类型的右操作数的运算符(或没有可接受的转换)”错误信息，这时要检查头文件中是否包含#include <string>。而在Eclipse中则不用如此设置（具体看编译器版本）。这与标准库实现的具体细节有关，在MSVC中，它在文件Program Files (x86)\Microsoft Visual Studio 9.0\VC\include\string中被实现，在GNU中，它在base_string.h中被实现。在使用std::string时，总是包含#include <string>是一个好习惯！

8、const对象默认为文件的局部变量

一般声明变量后可以在其它文件中通过extern关键字声明并使用该变量：

//文件1：
int counter;
//文件2：
extern int counter;
++counter;

但是如果是const则无法访问。可以通过显式指定extern关键字使其成为全局可访问对象：

//文件1：
extern const int bufSize = getBufSize();
//文件2：
extern count int bufSize;
//……使用bufSize

注解：非const变量默认为extern。要使const变量能够在其他的文件中访问，必须显式地指定它为extern。

9、引用

int ival = 1024;
int &refVal = ival;

当引用初始化后，只要该引用存在，就保持绑定到初始化时指向的对象。不可能将引用绑定到另一个对象。

也正因为如此，所以引用比指针的优势就在于：引用不可以在方法中篡改，这使得方法变量变得安全了。

10、const引用

const int ival = 1024;
const int &refVal = ival;

这里我们要求左侧的类型是一致的，包括const！

非const引用只能绑定到与该引用同类型的对象。
const引用则可以绑定到不同但相关的类型的对象或绑定到右值。（具体示例详见C++Primer v4 P52）

例如：

//错误代码
double dval = 3.14;
const int &ri = dval;

int temp = dval;
const int &ri = temp;

但是如下代码可以执行：

int ival = 1024;
const int &refVal = ival;
++ival;
//++refVal;    //error C3892: “refVal” 不能给常量赋值
std::cout<<"ival="<<ival<<"\trefVal="<<refVal<<std::endl;

输出：ival=1025    refVal=1025

const double dval = 3.14;
const int &ri = (int)dval;
std::cout<<ri<<std::endl;

记录C++ Primer学习中遇到的需要记忆的东西，这里仅以我个人为标准进行记录。

[格式]

以下样例代表了本文所描述的所有摘要片段将通过以下模版进行创建。

[正文]