Effective C++读书笔记~01 让自己习惯C++

目录

• 条款:01：视C++为一个语言联邦
  • 如何理解C++？
• 条款02：尽量以const，enum，inline替换#define
  • 两种替换#define特殊情况：
  • enum hack
  • 用template inline替换宏函数
• 条款03：尽可能使用const
  • const与迭代器
  • const成员函数
  • 成员函数如果是const意味着什么？
  • 在const和non-const成员函数中避免重复
  • 小结
• 条款04：确定对象被使用前已先被初始化
  • 对于内置型对象
  • 对于类对象
  • 不同编译单元内定义的non-local static对象的初始化次序
  • 小结

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

View C++ as a federation of languages.

如何理解C++？

将C++视为一个由相关语言组成的联邦而非单一语言。主要的4个次语言（sublanguage）：

• C， C++的基础
• Object-Oriented C++， C with Classes：构造函数、析构函数，封装，继承，多态，虚函数等。
• Template C++，C++泛型编程部分
• STL，template程序库，对容器、迭代器、算法、函数对象的规约有极佳的紧密配合与协调。

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

[======]

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

Prefer consts, enums, and inlines to #defines.

另一种理解：“编译器替换预处理器”

const等类型可以有编译器进行检查，而#define对编译器是透明的，无法利用编译器检查。

两种替换#define特殊情况：

1）定义常量指针（constant pointers）
如果是用char *定义常量指针，用于替换#define，必须写const两次。

const char *const authorName = "Scott Meyers";

如果是用string（通常比char *要合适）

const std::string authorName("Scott Meyers");

2）class专属常量
为了将常量的作用域（scope）限制于class内，必须让它成为class的一个成员（member）。而为确保此常量至多只有一份实体，必须让它成为static成员：

class GamePlayer {
private:
    static const int NumTurns = 5; // 常量声明式
    int scores[NumTurns]; // 使用该常量
};

const int GamePlayer::NumTerns; // NumTerns定义
// 为什么没有赋值？

上面定义NumTerns时，为什么没赋值？
因为经常把定义的式子放到实现文件（.cpp, .cxx）中，由于class常量已经在声明时获得初值（5），因此定义时不可再设初值。
当然也可以把初值放在定义中，而声明中不指定初值。

PS：#define无法创建一个class专属常量，因为宏一旦被定义，在其后的编译过程中有效（除非被#undef）

enum hack

1）替换static const
如果编译器必须在编译器就知道数组大小，static const方式无法做到，可以改成使用enum

class GamePlayer {
private:
    enum{ NumTurns = 5 }; // enum hack: NumTurns成为常量5的一个记号名称
    int scores[NumTurns]; // 使用该常量
};

2）实用主义
很多代码用了它，必须认识。也是模板元编程的基础技术。

用template inline替换宏函数

可以获得宏带来的效率以及一般函数的所有可预料行为和类型安全（type safety）
比如，用template inline函数callWithMax，替换宏函数，以a，b中较大者调用f。

// 不安全的宏函数
// 以a和b的较大者调用f
#define CALL_WITH_MAX(a, b) f((a) > (b) ? (a) : (b))

// 兼顾安全与效率的template inline函数
template<typename T>
inline void callWithMax(cosnt T& a, const T& b)
{
    f(a > b? a : b);
}

PS：
1）对于单纯常量，最好以const 对象或enum替换#define；
2）对于形似函数的宏（macro），最好改用inline函数替换#define；

[======]

条款03：尽可能使用const

Use const whenever possible.

顶层const：代表指针变量自身无法修改；
底层const：代表指针所指对象无法修改。

char* const p = "hello"; // 顶层const, const pointer, non-const data
const char *p = "hello"; // 底层const, non-const pointer, cosnt data

const与迭代器

迭代器的作用像T指针。
如果希望迭代器本身无法改变，而指向的内容可以改变，可以在迭代器前面加上const，即T const。
如果希望迭代器本身可以改变，而指向的内容不可改变，可以使用const_iterator，即const T*。

std::vector<int> vec;
...
const std::vector<int>::iterator iter = vec.begin(); // <=> T* const
*iter = 10; // OK
++iter; // error: iter 是const

std::vector<int>::const_iterator cIter = vec.begin(); // <=> const T*
*cIter = 10; // error: *cIter是const
++cIter; // OK

const成员函数

const成员函数不允许更改对象的任何变量（static除外）。目的在于确认该成员函数可作用于const对象身上。const成员函数很重要，原因：
1）使class接口比较容易被理解。因为很容易得知，哪个函数可以改动对象内容，而哪个函数不行。
2）使“操作const对象”成为可能。对编写高效代码是关键：以pass by reference-to-const方式传递对象（条款20）。？？

2个成员函数，如果只是常量性（constness）不同，可以被重载。non-const对象调用non-const function for non-const object, const 对象调用const function for const object。

class TextBlock
{
public:
       TextBlock(const char* s) : text(s) {}
       const char& operator[] (size_t position) const /* operator[] for const 对象 */
       {
              return text[position];
       }
       char& operator[] (size_t position) /* operator[] for non-const 对象 */
       {
              return text[position];
       }
private:
       string text;
};

non-const与const成员函数，在使用上的差异：

TextBlock tb("hello"); // non-const 对象
tb[0] = 'x'; // OK: 写一个non-const TextBlock
cout << tb[0] << endl; // OK: 调用non-const TextBlock::operator[]

const TextBlock ctb("hello"); // const 对象
ctb[0] = 'y';    // error: 写一个const TextBlock
cout << ctb[0] << endl; // OK: 调用const TextBlock::operator[]

注意：要修改string text，operator[] 返回值必须是引用类型（char &）或指针类型，不能是值。如果是值， 那么调用者修改的是tb[0]副本，而不是tb[0]本身。
比如，operator[] 返回char，下面句子无法通过编译：

tb[0] = 'x';

成员函数如果是const意味着什么？

这里有2个流行概念：bitwise constness（又称physical constness），logical constness。

1）bitwise constness
成员函数只有在不更改对象任何成员变量（static除外）时，才能说是const。i.e. 它不更改对象内的任何一个bit。编译器只需要寻找成员变量的赋值动作即可。bitwise constness是C++对常量性（constness）的定义，因此const成员函数不能更改对象内任何non-static成员变量。
但是，bitwise测试存在缺陷：如果类对象持有的是指针，bitwise测试能确保const成员函数不修改指针本身，但无法确保指针指向的内容不被修改。

class CTextBlock
{
public:
       CTextBlock(const char* s) { pText = new char[strlen(s) + 1]; strcpy(pText,  s); }
       ~CTextBlock() { delete[] pText; }
       char& operator[] (size_t position) const /* bitwise const声明, 确保operator[] 不修改pText */
       {
              return pText[position];
       }
       ...
private:
       char *pText;
};

// 以下内容能通过编译器
// 可以通过operator[]返回的指针, 修改pText指向的内容
const CTextBlock cctb("Hello"); // 声明一个常量对象
char *pc = &cctb[0];  // 调用const operator[]取得一个指针, 指向cctb第0个数据
*pc = 'J'; // 更新了cctb[0]内容

2）logical constness
由于bitwise constness并不能完全避免在const成员函数内修改处理对象内的bits，logical constness主张认为一个const成员函数可以修改它所处理的对象内的某些bits，但只有在客户端侦测不出的情况下才得如此。
例如，CTextBlock class有可能高速缓存（cache）文本区块的长度，以便应付查询：

class CTextBlock
{
public:
       // ...
       size_t length() const;
private:
       char *pText;
       size_t textLength;   // 最近一次计算的文本区块长度
       bool lengthIsValid;  // 目前的长度是否有效
};

size_t CTextBlock::length() const
{
       if (!lengthIsValid) {
              textLength = strlen(pText); // 错误：不能在const成员函数内修改对象属性textLength和lengthIsValid
              lengthIsValid = true;
       }
       return textLength;
}
// ...

上面length()的实现不是bitwise const，因为textLength和lengthIsValid都可能被修改，因此在用length()取得pText字符串最新长度时，需要重新计算、更新textLength和lengthIsValid的值。
而要在const成员函数内修改对象属性，可以用C++与const相关的摆动场：mutable（可变的）。mutable释放掉non-static成员变量的bitwise constness约束：

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

size_t CTextBlock::length() const
{
       if (!lengthIsValid) {
              textLength = strlen(pText); // OK
              lengthIsValid = true; // OK
       }
       return textLength;
}
// ...

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

虽然上面的例子中，用mutable可以解决在const成员函数中修改对象属性，但不能解决代码重复的问题。比如，const 成员函数和non-const成员函数，operator[] 都可能有边界检验、日志记录数据访问、检验数据完整性这相同的3步。

class TextBlock
{
public:
       TextBlock(const char* s) : text(s) {}
       const char operator[] (size_t position) const
       {
              // 边界检验 (bounds checking)
              // 日志记录数据访问(log access data)
              // 检验数据完整性(verify data integrity)

              return text[position];
       }
       char operator[] (size_t position)
       {
              // 边界检验 (bounds checking)
              // 日志记录数据访问(log access data)
              // 检验数据完整性(verify data integrity)

              return text[position];
       }
private:
       string text;
};

能否把这些重复的代码，利用起来呢？编写一次，使用2次。
答案是可以的，可以将常量性转除（casting away constness）：利用non-const函数调用cast函数，首先需要转型，然后去掉const修饰：

class TextBlock
{
public:
       TextBlock(const char* s) : text(s) {}
       const char& operator[] (size_t position) const
       {
              // 边界检验 (bounds checking)
              // 日志记录数据访问(log access data)
              // 检验数据完整性(verify data integrity)

              return text[position];
       }
       char& operator[] (size_t position)
       {
              // 边界检验 (bounds checking)
              // 日志记录数据访问(log access data)
              // 检验数据完整性(verify data integrity)

              return const_cast<char &>(static_cast<const  TextBlock&>(*this)[position]);
       }
private:
       string text;
};

这里有2个转型动作：
1）让non-const operator[]调用其兄弟const operator[]，通过static_cast将*this由原始类型TextBlock& 安全转型为const TextBlock&；
2）再从const operator[]的返回值中，通过const_cast移除const。该步当然也可以选择用C风格的强制类型转换，不过并不推荐；

为避免重复，为什么只能是令non-const版本调用const的operator[]，而不能是const版本调用non-const的？
因为const成员函数承诺绝不改变其对象的逻辑状态（logical state），non-const成员函数没有这样的承诺。如果在const函数中调用了non-const函数，就是冒了这样的风险。而non-const函数中调用const函数却不会带来风险。

小结

• 将某些东西声明为const，可以帮助编译器检查出错误用法。const可被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数；
• 编译器强制实施bitwise constness（const成员函数要求不能修改任何对象属性），编写代码时应该使用“概念上的常量性”（conceptual constness）（用mutable在const成员函数修改对象属性）；
• 当const和non-const成员函数有着实质等价实现时，可以令non-const版本调用const版本避免代码重复。

[======]

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

Make sure thath objects are initialized before they're used.

对于内置型对象

内置类型对象x，在某些语境下保证被初始化为0，不过其他语境并不能保证为0。例如，

// 作为全局变量
int x; // 0

// 作为自动变量
void fun() {
    int x; // x不能保证为0
}

// 作为类对象变量的成员
class Point {
    int x, y; 
};

Point p; // 全局变量p确保x为0

最佳解决办法：手工在使用对象之前现将其初始化。

int x = 0; // 对int手工初始化
const char* text = "A C-style string"; // 对指针手工初始化

double d;
std::cin >> d; // 以读取input stream方式完成初始化

对于类对象

使用构造函数（constructor）：确保构造函数都将对象的每个成员初始化。
需要注意：在构造函数中使用member initialization list（成员初值列），才是初始化成员；而构造函数体内使用赋值操作，是赋值（assignment）而非初始化（initialization）。

class PhoneNumber
{
public:
       string number;
};
class ABEntry
{
public:
       // case1 构造函数体内对class成员进行赋值
       ABEntry(const string& name, const string& address, const list<PhoneNumber>&  phone)
       {
              /* 这些都是赋值（assignment）, 而非初始化 */
              theName = name; // 如果是类对象, 赋值（=）操作会调用拷贝构造函数; 如果是基本类型, 则直接赋值
              theAddress = address;
              thePhone = phone;
              numTiemsConsulted = 0;
       }

       //  case2 使用member initialization list构造ABEntry对象
       ABEntry(const string& name, const string& address, const list<PhoneNumber>&  phone)
              : theName(name), // 调用theName的default构造函数, 从而构造成员对象
              theAddress(address),
              thePhone(phone),
              numTimesConsulted(0)
       {}
private:
       string theName;
       string theAddress;
       list<PhoneNumber> thePhone;
       int numTimesConsulted;
};

1）case1 构造函数体内对class成员进行赋值，实际上在进入构造函数体之前，会调用构造函数对各对象成员进行初始化。构造函数体内是赋值操作，而非初始化。
2）case2 是推荐的做法，在进入构造函数前，就进行了成员初始化。

因此，case1 相当于下面的代码，可以看出对成员相当于调用了2次赋值操作：

...
// case1 构造函数体内对class成员进行赋值
ABEntry(const string& name, const string& address, const list<PhoneNumber>&  phone)
	: theName(), // 构造成员对象
	theAddress(),
	thePhone(),
	numTimesConsulted(0)
{
	/* 这些都是赋值（assignment）, 而非初始化 */
	theName = name; // 如果是类对象, 赋值（=）操作会调用拷贝构造函数; 如果是基本类型, 则直接赋值
	theAddress = address;
	thePhone = phone;
	numTiemsConsulted = 0;
}
...

注意：如果成员过多，或者无需初值，可以在成员初值列中忽略该成员，这样它就没有初值。

关于成员初始化次序：
member initialization list中对象成员初始化次序，以防漏掉，或者导致检阅者迷惑，建议与声明的顺序保持一致。

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

static对象，其寿命从被构造出来直到程序结束为止。因此stack和heap-based对象都不是static对象。static对象包括：global对象、定义于namespace作用域内的对象，在class内、函数内、file作用域内被声明为static的对象。函数内的static对象称为local static对象，其他static对象都称为non-local static对象。
编译单元（transitation unit）：指产出单一目标文件（sigle object file）的那些源码。通常是单一源码文件（.c, .cpp, .cxx）加上所包含的头文件（#include files）。

问题：如果编译单元A内的某个non-local static对象的初始化动作，使用了另一个编译单元B内的某个non-local static对象，A初始化时，B可能没有被初始化。而C++对定义于不同编译单元内的non-local static对象的初始化次序，并没有明确的规定（事实上也很难做到）。

// FileSystem.h
class FileSystem {
public:
    ...
    size_t numDisks() const;
    ...
};

extern FileSystem tfs; // 声明global 对象tfs, 属于non-local static对象

// Directory.h
class Directory {
public:
    Director(params);
    ...
};
extern Directory tempDir;

// Directory.cpp
Director::Director(params)
{
    ...
    size_t disks = tfs.numDisks();// 错误：使用tfs对象, 但C++无法保证位于编译单元FileSystem.o中的FileSystem tfs已经初始化完成
}

如何解决这个问题？
可以将B的non-local static对象通过函数包装起来，替换为local static对象，A只需要通过这个包装函数访问B的local static对象即可。类似于单例模式。

// FileSystem.h
class FileSystem { ... };
// reference-returning函数, 返回local static对象引用
FileSystem& tfs() // 用于替换tfs对象, 将non-local static对象tfs替换为local static对象, 并返回其reference
{
    static FileSystem fs; // 这里会调用FileSystem构造函数, 确保fs初始化完成
    return fs;
}
// Directory.h
class Directory { ... };
// Directory.cpp
Directory::Directory(params)
{
    ...
    size_t disks = tfs().numDisks();
    ...
}
// reference-returning函数, 返回local static对象引用
Directory& tempDir() // 用于替换tempDir对象
{
    static Directory td;
    return td;
}

如果这种reference-returning函数，被频繁调用，还可以声明为inline函数。

缺点：
由于函数内含static对象（带有状态），在多线程系统中带有不确定性。解决办法是在程序单线程启动阶段，手工调用所有reference-returning函数，可消除与初始化有关的“竞争条件（race conditions）”。

注意：
绝对要避免这种尴尬状况：对象A初始化依赖于对象B，而对象B的初始化又要依赖于A。

小结

• 为内置型对象进行手工初始化，因为C++不保证初始化它们；
• 构造函数最好使用成员初值列表（member initialization list），而不要在构造函数本地内用赋值操作（assignment）。初值列列出的成员变量，其排列次序应该和它们在class中声明的次序相同；
• 为免除“跨编译单元之初始化次序”问题，请以local static对象替换non-static对象；

[======]