Effective C++ 读书笔记：C++ 编程习惯与最佳实践

// 值得一提的是我们无法使用#define，它并不重视作用域
// 如果你的编译器不支持 static 整数型 class 常量完成初值设定时
class GamePlayer2 {
 enum{ NumTurns = 5 };
 int scores[NumTurns];
};
// 但是注意，enum 无法取地址

示例验证：宏的副作用问题

// 宏的问题：++a 被执行 2 次，最终 a=7
int a=5, b=0;
#define CALL_MAX(a,b) f((a)>(b)?(a):(b))
CALL_MAX(++a, b);
// inline 模板函数：++a 仅执行 1 次，最终 a=6
template<class T> inline void callMax(T& a, T& b) {
 f(a>b?a:b);
}
callMax(++a, b);
// 替换方法
template<class T> inline void callWithMax(T& a,T& b){ f(a>b?a:b); }

请记住:

• 对于单纯变量，最好用 const 对象或 enums 替换#define
• 对于形似函数的宏，最好改用 inline 函数

3. Use const whenever possible 尽可能使用 const

const 的核心是'只读约束'，帮助编译器检测错误（比如意外修改值），提升代码安全性，主要有 4 个使用场景：

（1）迭代器 / 指针的 const

类比指针的 const 规则，区分两种 const：

• const vector<int>::iterator iter：迭代器本身不可改（类似 T* const），但可以通过 iter 修改指向的元素；
• vector<int>::const_iterator iter：迭代器指向的元素不可改（类似 const T*），但迭代器本身可以移动。

// STL 迭代器系是以指针为根据塑模出来的，所以迭代器的作用就像个 T*
std::vector<int> vec;
const std::vector<int>::iterator iter = vec.begin(); // T* const
std::vector<int>::const_iterator iter1 = vec.begin(); // const T*

（2）函数返回值的 const

避免客户的错误操作，比如：

// 令函数返回一个常量值，可以降低因客户错误而造成的意外，且不至于放弃安全性和高效性
class Rational{};
const Rational operator*(const Rational& lhs,const Rational& rhs);
// 保证了客户不会使用 (a*b)=c，if(a*b = c) 这种行为的出现

（3）const 成员函数

• bitwise constness（语法层面）：不修改类的非 const 成员（编译器强制检查），但存在漏洞（比如修改指针指向的内容）；

logical constness（逻辑层面）：允许修改 mutable 修饰的成员（客户端不可感知），比如缓存计算结果：

// const 成员函数
// 注意：成员函数的常量性也属于函数签名，可以被重载
// 现在对成员函数 const 由两个流行概念
// 1.bitwise constness 不应该改变对象内任何 non-const 成员
class CTextBlock{
 public:
  char& operator[](int index)const{ return pText[index]; }
 private:
  char* pText;
};
// 这个符合这个概念 (能通过 bitwise 测试), 但是却可以改变指针指向的对象
// 由这种情况引出了
// 2.logical constness
// 一个 const 成员函数可以改变它所处理对象的 bits，但只有在客户端侦测不出的情况下
class CText{
 public:
  std::size_t length()const;
 private:
  char* pText;
  std::size_t textLength;
  bool lengthValidity;
};
std::size_t CText::length()const{
 if(!lengthValidity){
  textLength = strlen(pText);
  lengthValidity = true;
 }
 return textLength;
}
// 但是会报错，需要将两个成员 (textlength 和 lengthValidity) 前加上 mutable 关键词

（4）const/non-const 成员函数复用

避免重复代码，让 non-const 版本调用 const 版本（通过类型转换解除 const）：

// 在 const 和 non-const 成员函数中避免重复
// 假设 operator[] 里还要执行边界检验，注意访问信息等行为，就会有很多重复代码出现
// 这个时候可以令其中一个调用另一个，这促使我们将常量性转除
// 一般而言，转型是一个很糟糕的想法 (27)
class TextBlock{
 public:
  const char& operator[](int index)const{ /* ... */ return pText[index]; }
  char& operator[](int index){
   return const_cast<char&>(static_cast<const TextBlock&>(*this)[index]); // 这里如果不转型为常量，就会无限递归自己
  }
 private:
  char* pText;
  std::size_t textLength;
};
// 更值得了解的是，如将 const 转为 non-const，就把权力放大了

请记住:

• 将某些对象声明为 const 可以帮助编译器侦测出错误用法
• 编译器强制实施 bitwise constness，但你写程序时应该遵守概念上的常量性
• 当 const 和 non-const 成员函数有实质等价的实现时，令 non-const 版本调用 const 版本可以避免代码重复

4. Make sure that objects are initialized before they are used 确保对象使用前已初始化

C++ 对内置类型（int、指针等）不保证初始化，类类型虽会调用构造函数，但错误的初始化方式会导致效率 / 逻辑问题：

（1）构造函数：初始化列替代赋值

注意：初始化列的顺序与类内成员声明顺序一致，与书写顺序无关（建议保持一致，提升可读性）。

// 规则很简单：确保每一个构造函数都将对象得每一个成员初始化
class ABEntry{
 private:
  std::string theName;
  std::string theAddress;
  int numTimes;
 public:
  ABEntry(std::string name,std::string address,int numTimes){
   theName = name;
   theAddress = address;
   numTimes = numTimes; // 这些都是赋值，不是初始化
  }
};

// 在赋值之前，会调用成员的默认构造函数，但却因为赋值的存在而浪费了开销
// 解决方法：使用 member initialization list
class ABEntry2{
 private:
  std::string theName;
  std::string theAddress;
  int numTimes;
 public:
  ABEntry2(std::string name,std::string address,int numTimes) :theName(name),theAddress(address),numTimes(numTimes){ }
};
// 这样就只是调用 copy 构造函数了
// 由于 numTimes 是内置类型，若成员初值列遗漏了它，就会有不明确行为
// 但是 const 或 references，一定需要初值，不能被赋值
// 成员初始化顺序与初值列顺序无关 (最好一致来增加可读性)，与声明顺序有关

（2）static 对象的初始化陷阱

static 对象（寿命从构造到程序结束）的坑：跨编译单元的 non-local static 对象初始化顺序不确定，解决方案是用 local static（函数内 static）：

// static 对象
// 寿命从被构造出来直到程序结束
// 函数内的 static 对象称为 local static
// 当有多个源码文件时，non-local static 对象的初始顺序是不确定的 (不小心可能会导致使用未被初始化的对象)
// C++ 对'多个编译单元的 non-local static 对象的初始化相对顺序无明确定义'
// 一个小小的设计，用 local static 对象替换 (单例模式的思想之一) 基础在于 C++ 保证，函数内的 local static 对象会在首次遇上定义式时被初始化
class FileSystem{};
FileSystem& tfs(){
 static FileSystem fs;
 return fs;
}
// 但是内含 static 对象使它们在多线程系统中具有不确定性

注意：local static 在多线程环境下可能有初始化竞争，需额外加锁。

请记住:

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