Effective C++ —— 让自己习惯C++（一）

条款01 ： 视C++为一个语言联邦

　　C++ == C（C基本语法） + Object-Oriented C++(类，封装，继承，多态……) + Template C++（泛型编程） + STL（容器，迭代器，算法，函数对象） .

故而：

　　C++高效编程守则视状况而变化，取决于你使用C++的哪一部分。

条款02 ： 尽量以const，enum，inline 替换#define

　　1. #define 不被视为语言的一部分，其所定义的符号未被加入记号表(symbol table)内，宏内无法设置断点，无法被跟踪调试；

　　2. #define 定义形似函数的宏(而不是定义一个常量)，即使已经为宏中的所有实参加上小括号，仍有可能会遭遇麻烦(比如参数为 ++i 运算符)。

注意：

　　1. 无法利用#define创建一个class专属常量(当然，宏也不能够提供任何封装性)，因为#defines并不重视作用域(scope).一旦宏被定义，他就在其后的编译过程中有效(除非在某处被#undef)。

　　2. 以定义类的专属常量为例，部分编译器不允许static成员(定义为static，确保此常量至多只有一个)在其声明式上(一般是位于头文件内)获得初值，所谓的“in-class 初值设定”也只允许对整数常量进行。如下：

class CostEstimate
{
private:
       static const double FudgeFactor;   // static class 常量声明，位于头文件(.h)内
       .......
       enum {NumTurns = };    // 枚举变量，用于在类声明式中提供必要的并且需要初值设定的常量
       int scores[NumTurns ];    // 使用枚举常量
};

const double CostEstimate:FudgeFactor = 1.35;     // static class 常量定义，位于实现文件(.cpp)内

可以使用枚举值来补偿“in class 初值设定”，其理论基础是：''一个属于枚举类型的数值可权充ints被使用"。枚举类型的行为某方面说比较像#define而不像const。例如取一个const地址是合法的，但取一个enum的地址就不合法，而取一个#define的地址通常也不合法。

故而：

　　1. 对于单纯常量，最好以const对象或enums替换#defines；

　　2. 对于形似函数的宏(macros), 最好改用inline函数替换#defines。

条款03 ： 尽可能使用const

　　const允许你指定一个语义约束，而编译器会强制实施这项约束。

　　1. const修饰指针，具体如下：

char greeting[] = "Hello";
char *p = greeting;   // non-const pointer,non-const data
const char *p1 = greeting;   //等价于“char const * p1 = greeting;” , non-const pointer,const data
char * const p2 = greeting;    // const pointer,non-const data,类似引用(指向不可更改)
const char * const p3 = greeting;   // const pointer,const data

注意：对于p1指针，其所指物为const data，但这仅限对于p1指针来说是const data，如果此时用另外一个普通指针ptr同时指向p1所指物，则可以通过ptr指针修改所指物。

　　2. const成员函数

　　将const实施于成员函数的目的，是为了确认该成员函数可作用于const对象。

　　bitwist constness 阵营相信，成员函数只有在不更改对象之任何成员变量(static除外)时才可以说const。bitwist constness正是C++对常量性(constness)的定义,因此const成员函数不可以更改对象内任何non-static成员变量. 但却有例外：具体的说，一个更改了“指针所指物”的成员函数虽然不能算const，但如果只有指针(而非其所指物)隶属于对象，那么却可以通过定义一个普通指针ptr，指向类中成员指针所指物，则可以通过ptr修改所指物(此为上一点所描述的情况)，这就导致了反直观结果：我们定义const的本意是不修改所指物。如下：

class CTextBook {
public:
    ...
　　 // 函数后面的const表明不会修改对象的non-static成员变量,仅仅对于类成员函数而言需要这个限定,非类成员函数没有对象概念
    char& operator[](std::size_t position) const{return pText[position];}
private:
    char * pText;    //只有指针隶属于对象
};

const CTextBook cctb("Hello");    //声明一个常量对象
char * pc = &cctb[];    //调用const operator[]取得一个指针，指向cctb数据

*pc = 'J';     // cctb现在有了“Jello”这样的内容,参见 C++易混淆知识点整理 第1点

　　如果需要在const成员函数内修改某些non-static成员变量的值，则可以通过对此成员变量添加一个与const相关的摆动场:mutable（可变的）。mutable释放掉non-static成员变量的bitwise constness约束。如下:

class CTextBlock{
public:
    .....
    std::size_t length() const;
private:
    char * pText;
    mutable std::size_t textLength;          // 这些成员变量可能总是会被更改,即使在const成员函数内
    mutable bool lengthIsValid;
};

std::size_t CTextBlock::length() const     // const的含义就是不修改对象内的任何non-static成员变量
{
    if(!lengthIsValid){
        textLength = std::std::strlen(pText);       // 如果没有给textLength指定mutable,这里不能赋值,因为指定了mutable,
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　所以即便在const成员函数内,也可以修改non-static成员变量的值
        lengthIsValid = true;
    }
}

　　3. 在const和non-const成员函数中避免重复

　　当const和non-const成员函数有着实质等价的实现时，令non-const版本调用const版本可避免代码重复。如下：

Class TextBook{
public:
   .....
const char& operator[](std::size_t position) const
    {
        .....
        .....
        return text[position];
    }

char& operator[](std::size_t position)
    {
       return
             const_cast<char&>(    // 将op[]返回值的const移除(常量性移除)
                   static_cast<const TextBook&>(*this)    // 为*this加上const，使之能够调用到const op[]
                          [position]
             );
     }
}

故而：
　　1. 将某些东西声明为const可帮助编译器侦测出错误用法。const可被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数本体。

　　2. 编译器强制实施bitwise constness ，但你编写程序时应该使用“概念上的常量性”(conceptual constness).

　　3. 当const和non-const成员函数有着实质等价的实现时，令non-const版本调用const版本可避免代码重复。

条款04 ： 确定对象被使用前已先被初始化

　　如果使用C part of C++而且初始化可能招致运行期成本，那么就不保证发生初始化。一旦进入non-C part of C++，规则有些变化。这就很好的解释了为什么array（来自C part of C++）不保证其内容被初始化，而vector(来自STL part of C++)却有此保证。

　　最佳的处理方法就是：永远在使用对象之前先将它初始化。

　　1. 对于无任何成员的内置类型，你必须手工完成初始化。

　　2. 至于内置类型以外的任何其他东西，初始化责任落在构造函数(constructors)身上。规则很简单：确保每一个构造函数都将对象的每一个成员初始化。

注意：

　　别混淆了赋值和初始化(使用成员初值列)。例如：

class PhoneNumber{ ...... };
class ABEntry {
public:
    ABEntry (const std::string& name, const std::string& address, const std::list<PhoneNumber>& phones );
private:
    std::string& theName;
    std::string& theAddress;
    std::list<PhoneNumber> thePhones;
    int numTimesConsulted;
};

------------------------ Method1 ： // 这些都是赋值，而非初始化
--------------------------------------------------
   ABEntry :: ABEntry (const std::string& name, const std::string& address, const std::list<PhoneNumber>& phones )
{
      theName = name;      // 这些都是赋值，而非初始化
      theAddress= address;
      thePhones= phones ;
      numTimesConsulted= ;
}

-------------------------- Method2 ： // 这些才是初始化-----------------------------------------
ABEntry :: ABEntry (const std::string& name, const std::string& address, const std::list<PhoneNumber>& phones )
        : theName(name),      // 这些都是初始化
        theAddress(address),
        thePhones(phones) ,
        numTimesConsulted()
{   }    // 构造函数本地不必有任何动作        

C++ 规定，对象的成员变量的初始化动作发生在进入构造函数本体之前。

　　Method2和Method1的最终结果相同，但通常效率较高。基于赋值的那个版本(Method1)首先调用default构造函数为theName，theAddress和thePhones设初值，然后立刻再对他们赋予新值。default构造函数的一切作为因此浪费了。成员初值列的做法(Method2)避免了这一问题，因为初值列中针对各个成员变量而设的实参，被拿去作为各个成员变量值构造函数的实参。本例中的theName以name为初值进行copy构造，等等。
　　对于内置类型对象如numTimesConsulted，其初始化和赋值的成本相同，但为了一致性最好也通过成员初值列来初始化。但注意，如果成员变量是const或references，它们就一定需要初值，不能被赋值(const或reference的值不能被修改,也就不可能在后面被赋值,所以只能在初始化的时候给予初值)。

　　3. “不同编译单元内定义之non-local static对象” 的初始化次序

　　　　non-local static对象：函数内的static对象称为local static对象(对于函数而言是local)，其他static对象称为non-local static对象。

　　　　编译单元： 是指产出单一目标文件的那些源码。基本上它是单一源码文件加上其所含入的头文件。

　问题：如果某编译单元内的某个non-local static对象的初始化动作使用了另一编译单元内的某个non-local static对象，它所用到的这个对象可能尚未被初始化，因为C++对“定义于不同编译单元内的non-local static对象”的初始化次序并无明确定义。原因在于，决定它们的初始化次序相当困难，非常困难，根本无解。

　　解决方案：将每个non-local static对象搬到自己的专属函数内（该对象在此函数内被声明为static）。这些函数返回一个reference指向它所含的对象。然后用户调用这些函数，而不是直接指涉这些对象。换句话说，non-local static对象被local static对象替换了。Design Patterns可能认出来了，这是Singleton模式(单例模式)的一个常见实现手法。

　　上面解决方案的理论基础是：C++保证，函数内的local static对象会在“该函数被调用期间” ， “首次遇上该对象之定义式”时被初始化。所以如果你以“函数调用”（返回一个reference指向local static对象）替换“直接访问non-local static对象”，你就获得了保证，保证你所获得的那个reference将指向一个历经初始化的对象。同时，如果你从未调用non-local static对象的“仿真函数”，就绝对不会引发构造和析构成本。如下：

class FileSystem{
  .....
  std::size_t numDisks() const;
  .....
};
FileSystem& tfs()
{
    static FileSystem fs;
    return fs;
}

class Directory {
   .....
   Directory (params);
   .....
};
Directory::Directory(params)
{
     ....
     std::size_t disks = tfs().numDisks();
     ....
}

Directory& tempDir()
{
    static Directory td;
    return td;
}

故而：
　　1. 为内置型对象进行手工初始化，因为C++不保证初始化它们（C part of C++）；

　　2. 构造函数最好使用成员初值列，而不要在构造函数本体内使用赋值操作。初值列列出的成员变量，其排列次序应该和它们在class中的声明次序相同。

　  3. 为避免“跨编译单元之初始化次序”问题，请以local static 对象替换 non-local static对象。