C++学习笔记，已结束

2011.5.23
第一章    快速入门
    这一章让我见识了下C++程序是什么样子的，以及了解了一点非常重要的概念：类。大概看下，明白个大意就行了。
    在整个学习过程中，我比较注重对正确做法的理解或选择相对省事的做法，可能会省略掉一些关于错误行为的分析和解释。
    值得注意的有：
        1.C++中，每个表达式都产生一个结果。   输出操作(std::cout <<)返回值是输出流本身，输入流同样。
        2.命名空间(namespace)的概念。    在初级学习中，一般加上using namespace std;即可。
        3.从开始学习，就应该养成遵循规范的良好习惯。    比如#include <iostream>与C语言中的区别。
        4.在适当位置声明变量，更有助于规范程序思路。    比如for(int i = 1; i <= 10; ++i);

    就以最基本的一个C++程序来结束这一章的学习吧。
        //这是我的第一个C++程序
        //code by naruto01
        #include <iostream>
        int main()
        {
            for(int i = 1; i <= 10; ++i)
                if((i % 2) != 0)
                    std::cout << "Hello,World!" << std::endl;
            return 0;
        ｝
        
第二章    变量和基本类型
    本章介绍了C++变量和基本类型的相关内容，比较重要的有const限定符、引用、typedef以及类类型。
    2.1基本内置类型中，值得注意的是C++中把负值赋给unsigned对象是合法的，结果是该负数对2^n(n是该类型的存储位数)求模后的值。
    2.2字面值常量，有宽字符概念，即在字面值前面加L。 宽字符是一个字符用两个字节来存放。
    2.3变量
        注意“左值”和“右值”的概念。
            左值(lvalue)可以出现在赋值语句的左边或右边。
            右值(rvalue)只能在右边。
        C++中的标识符区分大小写。
        保持一致的命名习惯。
        在变量定义时指定了初始值，称为初始化。 要注意对未初始化的变量使用可能引起运行问题，所以最安全和容易的做法是对每个内置类型变量进行初始化。
        类通过构造函数进行初始化。
        变量名的作用域 http://learn.对作用域的解释很好理解
        引用使用&进行定义，并且必须初始化，不能定义引用的引用。
        typedef的使用目的：
            为了隐藏特定类型的实现，强调目的
            简化
            允许一种类型用于多个目的
        类在定义后面需要添加分号(;)。
            类中的操作和数据称为类的成员。
            访问标号这里介绍了有public、private。
            struct和class的唯一差别在于，class在没有访问标号时，任何成员都是private；struct则为public。   
        预处理时避免多重包含的技巧：
            #ifndef MY_MARK
            #define MY_MARK
            #endif
            
    一小段程序
        //myclass.h
        #ifndef MY_MARK
        #define MY_MARK
        #endif
        
        class my_class {
            public:
                std::string  str;
        };
        
        //主程序
        //code by naruto01
        #include <iostream>
        #include "myclass.h"

        typedef class my_class my_defed;

        int main()
        {
            my_defed test;
            std::string &ref = test.str;
            std::cin >> test.str;
            std::cout << "本体：" << test.str << std::endl;
            std::cout << "引用: " << ref << std::endl;
            return 0;
        }

2011.5.24
第三章    标准库类型
    在头文件中，必须总是使用完全限定的标准库名字。
    string类型的输入操作符需要注意有两点：
        1.读取并忽略开头所有的空白字符。
        2.读取字符直至再次遇到空白字符终止。   
    使用getline读取整行文本,和上述特点配合，可以有效分解句子中的单词。例子将在IO操作看到。
    string对象size()操作返回的是string::size_type类型。    这表示应使用相关库类型的配套类型，它们的使用与机器无关，并可以减少错误发生。
    在3.2.3的6中，有一例子string s5 = s1 + ", " + "world";     s1 + ", "    返回string对象，然后再与"world"进行连接。也体现了第一章的描述：C++中，每个表达式都产生一个结果。
    string对象字符处理的相关函数定义在cctype头文件中。    cname表示这个头文件源自C标准库。
   
    vector是同一种类型的对象的集合。使用应包含#include <vector>。
    vector是一个类模版，而vector<int>则是数据类型。
    vector是可以动态增长的。    简直太爽了，C写程序时一直愁数组大小不能更改，如果想动起来，就得自己进行内存管理，很麻烦，难怪vector应用很普遍。
    C++程序员习惯优先选用!=进行循环判断条件。
   
    迭代器是一种检查容器内元素并遍历元素的数据类型。    可以想象成一种智能、自适应的特殊指针，这样对于迭代器的操作，对于熟悉C的人来说，更快理解。
    每种容器通过begin和end函数返回迭代器。其中begin指向第一个元素，而end返回的是“容器末端元素的下一个”。
    任何改变vector长度的操作都会使已存在的迭代器失效。    在使用迭代器的时候，要特别注意当前使用迭代器是否仍然有效，这是很容易被忽视导致的错误。
   
    bitset类型使直接操作若干位提供了方便。
    size_t类型定义在cstddef中，是一个与机器相关的unsigned类型，大小足以保证存储内存中对象的大小。    在一些程序的源代码中经常看到这个类型，后面数组的下标也应使用size_t。
   
    //code by naruto01
    #include <iostream>
    #include <string>
    #include <cctype>
    #include <vector>

    //这里啰嗦一次，以后using namespace std；
    using std::cin;
    using std::cout;
    using std::endl;
    using std::string;
    using std::vector;

    int main()
    {
        string s;
        if(s.empty())
            cin >> s;
        s += " naruto01";
        cout << s << endl;
        //s转换成大写形式
        for(string::size_type ix = 0; ix != s.size(); ++ix)
            s[ix] = toupper(s[ix]);
        cout << s << endl;
   
        vector<int> ivec(12, 8);
        ivec.push_back(9);
        for(vector<int>::iterator iter = ivec.begin(); iter != ivec.end(); ++iter)
            *iter = 6;
      
        return 0;   
    }

第四章    数组和指针
    理解指针声明语句时，从右向左阅读方便理解。
    预处理器变量NULL在cstdlib头文件中定义。
    C++提供void*指针，只与地址值有关。
    注意区分指向const对象的指针(const int *p)、const指针(int *const p)、指向const对象的const指针(const int *const p)。    观察const修饰的对象有助于区分他们。
    在4.2.5中谈到指针和typedef给出一例:
        typedef string *pstring;
        const pstring cstr;
        其中cstr变量是什么类型？一般错误地认为是指向const string的指针是因为把typedef当作文本扩展。typedef定义了pstring是一个指针，所以const修饰指针。    这里提到并不是故意抠字眼，在编写代码中，应该尽可能帮助人理解代码意图，当然一些定义习惯还是应该学习的。
        
    C++提供了新的内存管理方法，new和delete。需要注意在new申请内存使用结束后，应及时delete进行释放。
        在释放数组时，应该的操作：delete [] pia;
        
    多维数组中，很容易搞混的就是“指针的数组”和“指向数组的指针”了。
        int (*p)[4];    //指向拥有4个int元素数组的指针(pointer to an array of 4 ints)    我感觉英文注释更直观，在此一并附上
        int *p[4];    //int指针的数组，有4个元素(array of pointers to int)
        小技巧：后缀运算符的优先级高于单目运算符，即优先级[] > *，所以先和谁结合，也就确实了是数组还是指针。    具体可以参考http://learn.
        
    这一章跟C基本没有什么差别，所以也就不再列程序了

2011.5.25
第五章    表达式
    一般情况下，表达式的结果是右值。    int var; ++var; var++;    这里的两个表达式结果则为左值。
    在进行expr1 && expr2或者expr1 || expr2的判断时，会有“短路求值”，所以不能指望在一个逻辑判断表达式中，可以完成所有预期的操作。    大一看过《编程卓越之道 第二卷：运用底层语言思想编写高级语言代码》，在讲到短路求值时，好像意思是说不同的语言有不同的求值顺序。在C++ Primer中说到“总是先计算其左操作数，然后再计算其右操作数”。(中文版P132)，应该仅指C++。
   
    位操作，不是循环移位，而是丢弃移出去的位，用0填充。
        原来在学习C语言过程中，就不是太注意。后来接触汇编，发现右移和左移代替一些乘除法的效率简直是惊人的，了解到补码这些概念后，在尝试把一段汇编代码翻译成C的时候，才意识到对“符号位”的操作存在空白。在P134中指出：“位操作符如何处理其操作数的符号位依赖于机器。”，最佳实践值得借鉴：“对于位操作符，由于系统不能确保如何处理其操作数的符号位，所以强烈建议使用unsigned整型操作数”。   
   
    复合赋值操作符，值得注意的是左操作数只计算了一次。    可能在一些小测试中，会用到这一点来坑害百姓哦。
   
    自增和自减操作符中，讲到了关于语言本身实现前置和后置操作的差别，前置操作更有效率。应该在没有差别时，优先使用前置操作。
   
    sizeof操作符返回的是一个对象或类型名的长度，单位是字节，返回值类型是size_t，编译时是常量。
   
    结合性中讲到的“左结合性”和“右结合性”。以前看书不是太肯定，这里尝试描述一下：从左到右就是左结合。
   
    不推荐死记硬背操作符的优先级，善于利用()，不过手边有一份优先级的表还是不错的选择。 ^ ^
   
    动态内存管理中，注意delete删除指针之后，该指针变成悬垂指针，应该及时将指针置0.
   
    类型转换中，有个const_cast，可以转换掉表达式的const性质，但书中提到，使用const_cast也总是预示着设计缺陷。
   
   
    本节不做程序为例。
   
第六章    语句
    在故意省略case后面的break语句是很罕见的，因此应该提供一些注释说明其逻辑。
    for循环语句，以前一直存在一个误区，以为必然会首先执行一次，类似do-while形式，其实是初始化语句(init-statement)结束后，求解判断条件(condition)。
    try/throw/catch在之前看的国内C教材，只在关键字中看到过，这里简单了解一下。主要有<stdexcept>中定义的若干标准异常类，定义了一个what的操作，没有任何参数，返回异常提供更详细的文字描述。
   
    预处理器调试时的常量：__FILE__    文件名、__LINE__    当前行号、__TIME__    文件被编译的时间、__DATE__    文件被编译的日期
    assert宏定义在cassert头文件，它的有效性取决于NDEBUG是否定义。使用assert来测试“不可能发生”的条件，如果assert宏求解条件表达式为false，则输出信息并且终止程序。
   
    对于异常处理这块，不是很感冒，所以也仅作了解。第一章程序已经使用了for、if，这里在此基础上仅仅简单地增加使用break。代码都会用到这几章的内容，是最普遍不过的基本组成部分了，所以也算是让自己好看点。多少复制点代码吧 - -#  唯一有价值的感觉就在注释的那句话。真不好意思。之后章节将只提供代码片段，重点快来咯。
   
    //code by naruto01
    #include <iostream>
    int main()
    {
        for(int i = 1; i <= 10; ++i)
            if((i % 2) != 0)
                std::cout << "Hello,World!" << std::endl;
            else if(7 == i)    //防止误写成i = 7的好办法
                        break;
        return 0;
    }   

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

Sales_item类有一构造函数:Sales_item(const string&)
如果这个构造函数被定义为explicit，那么上面语句的构造函数就不是显式的，应该初始化失败。对吧？

 
书中代码注释是：This initialization is okay only if the Sales_item(const string&) constructor is not explocot
但是下面中文翻译出：如果构造函数是显式的，则初始化失败；如果构造函数不是显式的，则初始化成功。

2011.5.27
第八章    标准IO库
    当一个类继承另一个类时，这两个类通常可以使用相同的操作。
    如果函数有基类类型的引用形参时，可以给函数传递其派生类类型的对象。
    wchar_t类型的标准输入对象是wcin;标准输出是wcout;而标准错误是wcerr。
    IO对象不可复制或赋值。
        只有支持复制的元素类型可以存储在vector或其他容器类型里。
        形参或返回类型不能为流类型。    如果想传递或返回IO对象，则必须传递或返回指向该对象的指针或引用。
    8.2.2给出代码中while(cin >> ival, !cin.eof())    解释下逗号操作符的求解过程：首先计算它的每一个操作数，然后返回最右边操作数作为整个操作的结果。
    flush操纵符不添加任何字符刷新流。 ends操纵符插入null。    endl输出一个换行符。
   
        如果程序崩溃，则不会刷新缓冲区，所以使用endl是个良好的习惯。
    使用tie函数可以将输入流和输出流绑在一起，任何读输入流的尝试都将首先刷新其输出流关联的缓冲区。
        例如cin.tie(&cout); ostream *old_tie = cin.tie(); cin.tie(0);
    IO标准库使用C风格字符串作为文件名。
        在尝试打开新文件之前，必须先关闭当前的文件流。
        如果遇到文件结束符或其他错误，将设置流的内部状态，以便之后不允许再对该流做读写操作。即使关闭流也不能改变流对象的内部状态。而调用clear后，就像重新创建了该对象。
        ifstream infile;
        ofstream outfile;
        infile.open("in");
        outfile.open("out");
        //通常检查打开是否成功，是个好习惯
        if(!infile && !outfile) {
            cerr << "error: unable to open input or output file: " << endl;
            return -1;
        }
        
        infile.close();    //关闭文件流
        infile.clear();    //重置流状态
        infile.open("next");
        
    以binary模式打开的流则将文件以字节序列的形式处理，而不解释流中的字符。
    以out模式打开的文件会被清空。如果要保存文件中已存在的数据，唯一方法是显示地指定app模式打开。
    ofstream outfile("file", ofstream::app);
   
    stringstream提供的转换或格式化：
        该对象的一个常见用法是，需要在多种数据类型之间实现自动格式化时使用该类类型。
        int val1 = 512, val2 = 1024;
        ostringstream format_message;
        //format_message内容：val1: 512\nval2: 1024\n
        format_message << "val1: " << val1 << "\n"
                                     << "val2: " << val2 << "\n";
        //自动将数值型数据的字符表示方式转换为相应的算术值
        istringstream input_istring(format_message.str());
        string dump;
        input_istring >> dump >> val1 >> dump >> val2;    //一般情况下，使用输入操作符读string时，空白符将会忽略(这里补充下空白符的概念：空格、制表符、垂直制表符、回车符、换行符和进纸符)
        

2011.5.31
第11章    泛型算法
    “泛型”指的是它们可以操作在多种容器类型上。
    算法有着一致的结构，了解算法的设计可使我们更容易学习和使用它们。
    泛型算法本身从不执行容器操作，只是单独依赖迭代器和迭代器操作实现。
    算法从不直接添加或删除元素。
    包含头文件#include <algorithm>
    在写容器元素的算法中，必须确保算法所写的序列至少足以存储要写入的元素。
        对指定数目的元素做写入运算，或者写到目标迭代器的算法，都不检查目标的大小是否足以存储要写入的元素。
    确保算法有足够的元素存储输出数据的一种方法是使用插入迭代器。
    谓词是做某些检测的函数，返回用于条件判断的类型，指出条件是否成立。
   
    插入迭代器是一种迭代器适配器，带有一个容器参数，并生成一个迭代器，用于在指定容器中插入元素。
        back_inserter、front_inserter、inserter
   
    可以比较两个istream迭代器是否相等，而ostream迭代器则不提供比较运算。
        下面给出一个流迭代器常用的例子：
            istream_iterator<int> cin_it(cin);    //在创建时，可直接绑定到一个流上。
            istream_iterator<int> end_of_stream;    //创建时不提供实参，则该迭代器指向超出末端位置。
            
            ostream_iterator<Sales_item> output(outfile, " ");    //分隔符必须是C风格字符串
    提供输入操作符(>>)的任何类型都可以创建istream_iterator对象。
    流迭代器的重要限制：
        不可能从ostream_iterator对象读入，也不可能写到istream_iterator对象中。
        一旦给ostream_iterator对象赋了一个值，写入就提交了。此外，每个不同的值都只能正好输出一次。
        ostream_iterator没有->操作符。
        
    sort调用完成后，重复输入的数就会相邻存储。
   
    流迭代器不能创建反向迭代器。
    反向迭代器用于表示的范围，和普通迭代用于表示的范围不对称。
   
    迭代器种类：输入迭代器、输出迭代器、前向迭代器、双向迭代器、随机访问迭代器
    除了输出迭代器，其他类别的迭代器形成了一个层次结构：需要低级类别迭代器的地方，可使用任意一种更高级的迭代器。
    关联容器的键是const对象，因此关联容器不能使用任何写序列元素的算法。
    在处理算法时，最好将关联容器上的迭代器视为支持自减运算的输入迭代器，而不是完整的双向迭代器。
    对于每一个形参，迭代器必须保证最低功能。
   
    算法最基本的性质是需要使用的迭代器种类。
    四种形式：
        alg(beg, end, other parms);
        alg(beg, end, dest, other parms);
        alg(beg, end, beg2, other parms);
        alg(beg, end , beg2, end2, other parms);
        1)dest形参是一个迭代器，用于指定存储输出数据的目标对象。
            算法假定无论需要写入多少个元素都是安全的。
            通常要使用插入迭代器或者ostream_iterator来。
                ostream_iterator则实现写输出流的功能，无需考虑所写的元素个数。
        2)beg2视为第二个输入范围的首元素
            算法假定以beg2开始的范围至少与beg与end指定的范围一样大
        
    重新对容器元素排序的算法使用<操作符，则第二个重载版本带有一个额外的形参，表示用于元素排序的不同运算。
    检查指定值的短发默认使用==操作符，带有谓词函数形参的算法，名字带有后缀_if。
    无论算法是否检查它的元素值，都可能重新排列输入范围内的元素。将元素写到指定的输出目标，在名字中添加后缀_copy。

2011.6.1
第12章    类
    成员可以是数据、函数或类型别名。
    构造函数初始化列表跟在构造函数的形参表之后，并以冒号开头。
    在类内部，声明成员函数是必需的，而定义成员函数则是可选的。
        类内部定义的函数默认为inline。
        成员函数有一个附加的隐含实参——this指针。
    const必须同时出现在声明和定义中。
   
    类背后蕴含的基本思想是数据抽象和封装。
    封装是一项将低层次的元素组合起来形成新的、高层次实体的技术。
    一个访问标号可以出现的次数通常是没有限制的。
    数据抽象和封装的两个重要有点：
        避免类内部出现无意的、可能破坏对象状态的用户级错误。
        随时间推移可以根据需求改变或缺陷报告来完善类实现，而无须改变用户级代码。
        
    类可以定义自己的局部类型名字，将这个类型设为public，就允许用户使用这个名字。
    成员函数只能重载本类的其他成员函数。
    不在类定义体内定义的inline成员函数，其定义通常应放在有类定义的同一头文件中。
        对于不完全类型，不能定义该类型的对象，只能用于定义指向该类型的指针及引用，或者用于声明使用该类型作为形参类型或返回类型的函数。
    定义类型时不进行存储分配。
    因为在类定义之后可以接一个对象定义列表。定义必须以分号结束。
   
    成员函数不能定义this形参。
    当我们需要将一个对象作为整体引用而不是引用对象的一个成员时，需要显式引用this。
    const成员函数只能返回*this作为一个const引用。
   
    可变数据成员永远都不能为const，const成员函数可以改变mutable成员。
   
    定义类型的成员，如Screen::index(称为完全限定名)，使用作用域操作符来访问。
    返回类型出现在成员名字前面，如果返回类型使用由类定义的类型，则必须使用完全限定名。
    在C++程序中，所有名字必须在使用之前声明。
    如果类作用域中使用的名字不能确定为类成员名，则在包含该类或成员定义的作用域中查找，以便找到该名字的声明。
    一旦一个名字被用作类姓名，该名字就不能被重复定义。
    尽管类的成员被屏蔽了，但仍然可以通过用类名来限定成员名或显式使用this指针来使用它。
    尽管全局对象被屏蔽了，但通过用全局作用域确定操作符(::)来限定名字，仍然可以访问。

2011.7.3
第15章    面向对象编程
    面向对象编程(Object-oriented programmingm OOP)基于三个基本概念：数据抽象、继承和动态绑定。
    多态性，通过继承而相关联的类型为多态类型，是因为在许多情况下可以互换地使用派生类型或基类型的“许多形态”。
    在C++中，多态性仅用于通过继承而相关联的类型的引用或指针。
    在C++中，基类必须指出希望派生类重定义哪些函数，定义为virtual的函数是基类期待派生类重新定义的，基类希望派生类继承的函数不能定义为虚函数。
    在C++中，通过基类的引用(或指针)调用虚函数时，发生动态绑定。
    继承层次的根类一般都要定义虚析构函数即可。
    在非虚函数的调用在编译时确定。除了构造函数之外，任意非static成员函数都可以是虚函数，保留字virtual不能用在类定义体外部出现的函数定义上。
    protected成员可以被派生类对象访问但不能被该类型的普通用户访问。
    派生类只能通过派生类对象访问其基类的protected成员，派生类对其基类类型对象的protected成员没有特殊访问权限。
        提供给派生类型的接口是protected成员和public成员的组合。
    类派生列表指定了一个或多个基类。
        访问标号决定了对继承成员的(最大)访问权限。        这句话自己添加的不是很确切，主要是指继承成员的访问权限等于或严格于派生类的访问标号、
            如果想要继承基类的接口，则应该进行public派生。        经常见到的也是这种派生方式。
    派生类一般会重定义所继承的虚函数。
        如果派生类没有重定义，则使用基类中定义的版本。
    派生类必须对想要重定义的每个继承成员进行声明。
        派生类中虚函数的声明必须与基类中的定义方式完全匹配。    一个例外：返回对基类型的引用(或指针)的虚函数，派生类中的虚函数可以返回基类函数所返回类型的派生类的引用(或指针)。
        派生类重定义虚函数时，可以使用virtual，但不是必须这样做。
   
    已定义的类才可以用作基类。
        暗示着不可能从类自身派生出一个类。
    基类本身可以是一个派生类。
    如果需要声明(但并不实现)一个派生类，则声明包含类名但不包含派生列表。
    可将基类类型的引用绑定到派生类对象的基类部分，指针也是如此。        这里注意是基类的引用或指针可以绑定到派生类上，反之则不行。
    任何可以在基类对象上执行的操作也可以通过派生类对象使用。
    引用和指针的静态类型与动态类型可以不同，这是C++用以支持多态性的基石。        静态类型：static type, 在编译时可知的引用类型或指针类型。        动态类型:dynamic type, 指针或引用绑定的对象的类型，这是仅在运行时可知的)。
        如果调用非虚函数，则无论实际对象是什么类型，都执行基类类型所定义的函数。
        只有通过引用或指针调用，虚函数才在运行时确定。
    非虚函数总是在编译时根据调用该函数的对象、引用或指针的类型而确定。
    只有成员函数中的代码才应该使用作用域操作符覆盖虚函数机制。
        最常见的理由是为了派生类虚函数调用基类的版本。
    通过基类的引用或指针调用虚函数时，默认实参为在基类虚函数声明中指定的值，如果通过派生类的指针或引用调用虚函数，则默认实参是在派生类的版本中声明的值。
   
    派生类可以进一步限制但不能放松对所继承的成员的访问。
    无论派生列表中是什么访问标号，所有继承Base的类对Base中的成员具有相同的访问。
    在继承层次的设计中，有一个重要概念：是一种(Is A) 有一个(Has A)
    为了使size在Derived中成为public，可以在Derived的public部分增加一个using声明:using Base::size; , 从而恢复继承成员的访问级别。
    私有继承相当罕见，所以如果确实需要，显式指定可避免误解。    struct派生则默认为public, class派生则默认为private。
   
    友元可以访问类的private和protected数据。
        友元关系不能继承。如果基类被授予友元关系，则只有基类具有特殊访问权限。
   
    每个static成员只有一个实例。
    确定派生类到基类转换的可访问性取决于在派生类的派生列表中指定的访问标号。
    从基类到派生类的自动转换是不存在的。        如果确定可以，需要使用static_case强制转换。
   
    构造函数和复制控制成员不能继承。
    派生类构造函数的初始化列表只能初始化派生类的成员，不能直接初始化继承成员。
        可以将基类包含在构造函数初始化列表中间接初始化。
        class Bulk_item : public Item_base {
        public:
            Bulk_item(const std::string& book, double sales_price,
                                std::size_t qty = , double disc_rate = 0.0) :
                                Item_base(book, sales_price),
                                min_qty(qty), discount(disc_rate) { }
        };
    一个类只能初始化自己的直接基类。        直接基类就是在派生列表中指定的类。
    派生类应通过使用基类构造函数尊重基类的初始化意图。
   
    具有指针成员的类一般需要定义自己的复制控制来管理成员。
    派生类析构函数不负责撤销基类对象的成员。
    基类中的析构函数必须是虚函数。
        即使析构函数没有工作要做，继承层次的根类也应该定义一个虚析构函数。
        强调之前，虚函数必须在基类和派生类中具有相同的形参。
   
    在继承情况下，派生类的作用域嵌套在基类作用域中。
    与基类成员同名的派生类成员将屏蔽对基类成员的直接访问。
        可以使用作用域操作符来访问被屏蔽的基类成员。
        设计派生类时，只要可能，最好避免与基类成员的名字冲突。
    在派生类作用域中派生类成员屏蔽基类成员，即使函数原型不同，基类成员也会被屏蔽。
   
    成员函数(无论虚还是非虚)可以重载。
        如果派生类重定义了重载函数，则通过派生类型只能访问派生类中重定义的那些成员。
        派生类不用重定义所继承的每一个基类版本，可以为重载成员提供using声明，一个using声明只能指定一个名字。
    通过基类类型的引用或指针调用函数时，编译器将在基类中查找该函数而忽略派生类。
   
    在函数形参表后面写上=0以指定纯虚函数。
        含有(或继承)一个或多个纯虚函数的类是抽象基类(Abstract base class)。
        不能创建抽象类型的对象。
        
    后面关于指针或引用管理的内容跳过。
   
第16章    模板与泛型编程
    这一章之所以阅读的主要原因在于看一位大牛的网站，他写的数据结构学习笔记，一直使用template的东西，简单阅读这一章，做到可以看懂代码即可，所以仅做了解。
   
    泛型编程就是以独立于任何特定类型的方式编写代码。
    模板是泛型编程的基础。
    函数模板是一个独立于类型的函数。
        template <typename T>
        int compare(const T &v1, const T &v2)
        {
            if (v1 < v2) return -1;
            if (v2 < v1) return 1;
            return 0;
        }
    inline函数模板，需要注意inline的位置:
        template <typename T> inline T min(const T&, const T&);
   
    书上16.1.2中，又一次提醒了关于重载条件的复习，详见P378.
   
    模板形参遵循常规名字屏蔽规则。与全局作用域中声明的对象、函数或类型同名的模板形参会屏蔽全局名字。
    每个非类型形参前面必须带上类型名字，省略关键字或类型说明符是错误的：
        template <typename T, U> T calc (const T&, const U&);
        改正为:template <typename T, typename U> T calc (const T&, const U&);
    typename显式指明一个名字是一个类型。所以在类型之前指定typename没有害处。
    在调用函数时非类型形参将用值代替，值的类型在模板形参表中指定。
        这里书上例子，很能说明问题：
            template <class T, size_t N> void array_init(T (&parm)[N])
            {
                for (size_t i = 0; i != N; ++i) {
                    parm[i] = 0;
                }
            }
            
            编译器从数组实参计算非类型形参的值：
            int x[42];
            double y[10];
            array_init(x);    // 实例化为array_init(int(&)[42])                            因为后面不再继续写了，所以这里提一下实例化的概念：产生模板的特定类型实例的过程称为实例化。
            array_init(y);    // 实例化为array_init(double(&)[10])
            对模板的非类型形参而言，求值结果相同的表达式将认为是等价的。调用的是相同的实例——array_init<int, 42>:
            int x[42];
            const int sz = 40;
            int y[sz + 2];
            array_init(x);
            array_init(y);
   
    编写泛型代码的两个重要原则：
        模板的形参是const引用。
        函数体中的测试只用<比较。        在本章笔记开头的代码就体现了这种优势。
            详细的原因，参见P534-P535