C++有4个主要的次语言（sublanguage）：
Tips：
该条款可表达为：宁可以编译器替换预处理器
#define ASPECT_RATIO 1.653
const double AspectRatio = 1.653; //以常量替换宏
替换原因：
常量指针（constant pointers）：常量定义式常位于头文件，故有必要将指针声明为const
const char* const authorName = "Scott Meyers";
const std::string authorName("Scott Meyers"); //使用string更合适
class专属常量：为了将常量作用于（scope）限制在class内，需要让其成为class的一个成员（member）；为了确保此常量至多只有一份实体，需要让其成为static成员
class GamePlayer {
private:
static const int NumTurns = 5; //常量声明式
int scores[Numturns]; //使用该常量
...
};
当某个东西是class专属常量+static+整数类型（integral type，如ints、chars、bools），只要不取地址，则可是有声明式而无定义式，否则需要提供定义式。
//应放入实现文件而非头文件
const int Gameplayer::NumTurns; //NumTurns的定义，声明时设定了初值故此处可不设定值
旧编译器可能不允许static成员在声明式上获得初值，此时可将初值放在定义式。
class CostEstimate {
private:
static const double FudgeFactor; //static class常量声明，位于头文件
};
const double CostEstimate::FudgeFactor = 1.35; //static class常量定义，位于实现文件
若译器不允许static成员在声明式上获得初值，且class编译期间需要一个class常量值（如存在数组声明式），则可用“the enum hack”补偿，利用枚举类型（enumerated type）的数值可充当ints使用的特点。
enum hack有以下特点：
class GamePlayer {
private:
enum { NumTurns = 5 }; //令NumTurns成为5的一个记号名称
int scores[NumTurns];
...
};
类似函数的宏（macros）没有函数调用（function call）带来的额外开销，但其缺点显著，最好替换为inline函数
//带宏实参的宏，每个实参都需要加上小括号，然而还是可能出现难以预料的问题
#define CALL_WITH_MAX(a, b) f((a) > (b) ? (a) : (b))
//使用template inline实现宏的高效以及函数的可预料性和类型安全性（type safety）
template<typename T>
inline void callWithMax(const T& a, const T& b)
{
f(a > b ? a : b);
}
Tips：
void f1(const Widget* pw); //被指物是常量
void f2(Widget const * pw); //同上
STL迭代器的作用类似T*指针，其同样有指针常量和常量指针的用法
std::vector<int> vec;
...
const std::vector<int>::iterator iter = vec.begin(); //指针常量
*iter = 10; //正确，改变iter所指物
++iter; //错误！iter本身是const
std::vector<int>::const_iterator cIter = vec.begin(); //常量指针
*cIter = 10; //错误！*cIter是const
++cIter; //正确，改变cIter本身
const成员函数有两个作用：
//两个成员函数如果只是常量性（constness）不同，可以被重载
class TextBlock {
public:
...
const char& operator[](std::size_t position) const //对于const对象的操作符[]
{ return text[position]; }
char& operator[](std::size_t position) //对于non-const对象的操作符[]
{ return text[position]; }
private:
std::string text;
};
//operator[]使用方式如下
TextBlock tb("Hello");
std::cout << tb{0]; //调用non-const TextBlock::operator[]
tb[0] = 'x'; //正确，写一个non-const TextBlock，operator[]返回reference to char
const TextBlock ctb("World");
std::cout << ctb[0]; //调用const TextBlock::operator[]
ctb[0] = 'x'; //错误！写一个const TextBlock，operator[]调用合法，但对其返回的const赋值非法
//更真实的例子
void print(const TextBlock& ctb) //此函数中ctb是const
{
std::cout << ctb[0]; //调用const TextBlock::operator[]
...
}
const成员函数有两个流行概念：
当只有指针（而非其所指物）隶属于对象，此时更改了指针所指物的成员函数不具备十足的const性质但编译器认为其满足bitwise const
class CtextBlock {
public:
...
char& operator[](std::size_t position) const //bitwise const声明，但不适当
{ return pText[position]; } //operator[]实现代码并不更改pText本身
private:
char* pText; //只有指针（而非其所指物）隶属于对象
}
const CTextBlock cctb("Hello"); //声明一个常量对象
char* pc = &cctb[0]; //调用const operator[]获得一个指针，指向cctb的数据
*pc = 'J'; //cctb变为"Jello"
当有些量需要修改而违反编译器的bitwise const，则可利用C++的一个与const相关的摆动场：mutable，释放掉non-static成员变量的bitwise constness约束
class CTextBlock {
public:
...
std::size_t length() const;
private:
char* pText;
mutable std::size_t textLength; //mutable使其可在const成员函数内更改
mutable bool lengthIsValid; //否则不能更改，编译器会坚持bitwise const
};
std::size_t CTextBlock::length() const
{
if (!lengthIsValid) {
textLength = std::strlen(pText); //正确，声明时有mutable，否则错误
lengthIsValid = true;
}
return textLength;
}
如果non-const和const operator[]相同，则代码会过长。可让non-const operator[]调用const operator[]避免代码重复。这需要将常量性转除（casting away constness）。
class TextBlock {
public:
...
const char& operator[](std::size_t position) const
{
... //边界检验（bounds checking）
... //志记数据访问（log access data）
... //检验数据完整性（verify data integrity）
return text[position];
}
char& operator[](std::size_t position)
{
return
const_cast<char&>( //将op[]返回值的const转除
static_cast<const TextBlock&>(*this) //为*this加上const
[position] //调用const op[]
);
}
private:
std::string text;
}
上述代码包含两个转型动作：
在const成员函数中调用non-const成员函数会有风险，因为对象有可能因此被改动。
Tips：
int x; //x在某些语境中会被初始化（为0），但是其他语境中不保证
class Point {
int x, y;
};
...
Point p; //p的成员变量有时候被初始化（为0），有时候不会
由于是否初始化难以确定，故最好永远在使用对象之前先将他初始化，对于内置类型以外的任何东西，确保每一个构造函数（constructors）都将对象的每一个成员初始化。
class PhoneNumber {...};
class ABEntry { // Addrress Book Entry
public:
ABEntry(const std::string& name, const std::string& address,
const std::list<PhoneNumer>& phones);
private:
std::string theName;
std::string theAddress;
std::list<PhoneNmuber> thePhones;
int numTimesConsulted;
};
ABEntry::ABEntry(const std::string& name, const std::string& address,
const std::list<PhoneNumer>& phones);
{
theName = name; //这都是赋值（assignments）而非初始化（initializations）
theAddress = address;
thePhones = phones;
numTimesConsulted = 0;
}
上述代码中，theName、theAddress、thePhones在进入ABEntry构造函数之前已经被初始化，而numTimesConsulted则不确定是否已被初始化。
ABEntry构造函数最好使用成员初值列（member initialization list）替换赋值动作
ABEntry(const std::string& name, const std::string& address,
const std::list<PhoneNumer>& phones);
:theName(name), //这些都是初始化
theAddress(address),
thePhones(phones),
numTimesConsulted(0)
{} //构造函数本体没有动作
ABEntry();
:theName(), //也可指定无物（nothing）调用default构造函数
theAddress(),
thePhones(),
numTimesConsulted(0)
{} //构造函数本体没有动作
初值列的性能消耗：
成员初值列的使用建议：
C++的初始化次序固定为：
需要额外关注不同编译单元内定义的non-local static对象，C++对这类对象的初始化次序无明确定义，故如果这类对象存在依赖关系可能会出问题。决定这类对象的初始化次序非常困难，最常见的形式是经由模板隐式具现化（implicit template instantiations）形成
//假设自己有一个FielSystem Class
class FileSystem {
public:
...
std::size_t numDisks() const;
...
};
extern FileSystem tfs;
//假设客户在其他位置建立一个class以处理文件系统内的目录
class Directory {
public:
Directory( *params* );
...
};
Directory::Directory( *params* )
{
...
std::size_t disks = tfs.numDisks(); //使用tfs对象
...
}
Directory tempDir( *params* ); //放临时文件的目录
上述代码无法保证tfs在tempDir之前被初始化
解决方案：将每个non-local static对象搬到自己的专属函数内并声明为static，这些函数返回一个reference指向它所含的对象。换句话说，non-local static对象被替换为local static对象，这是单例（Singleton）模式的一个常见实现手法。
class FileSystem {...}; //同前
FileSystem& tfs() //初始化一个local static对象并返回指向其的reference
{
static FileSystem fs;
return fs;
}
class Directory {...}; //同前
Directory::Directory( *params* )
**{
...
std::size_t disks = tfs().numDisks(); //调用tfs函数，而非直接用reference to tfs
}
Directory& tempDir()
{
static Directoy td;
return td;
}
reference-returning函数=定义并初始化一个local static对象+返回它
由于在多线程环境下任何non-const static对象都会有麻烦，则可在程序的单线程启动阶段（singl-threaded startup portion）手工调用所偶reference-returning函数，以消除与初始化有关的竞速形式（race conditions）
Tips：