条款3：尽可能使用const
简单来说，当我们希望某个值（这个值，可以是变量，成员函数等等）不能被改变时，就应该为该值声明为const类型，告诉编译器同时也告诉我们自己，这个值后续不能被改变，防止后续误操作，从而导致结果与预期违背。比如，我们定义一个圆周率Pi，Pi等于3.14，这是一个不争的事实，这时就需要为Pi变量加上const限定，防止我们写出这样的代码：
double Pi = 3.14; //正确：const double Pi = 3.14; int main() { int val = 1; if (Pi = val) { cout << "Pi: " << Pi << endl; } return 0; }
在将Pi与某个变量进行对比时，不小心将==写成了=，导致修改了Pi的值，而将Pi声明为const，在一些编译器的静态语法检测时期就能帮我们检查出这种错误。
同样，当我们定义一种自己的类型时，也需要在合适的地方使用const，比如，定义一个MyInt类型：
class MyInt { public: MyInt() {} MyInt(int val) { this->val = val; } friend ostream& operator<<(ostream &out, const MyInt &myInt); friend MyInt operator*(const MyInt &myInt1, const MyInt &myInt2); bool operator==(const MyInt &myInt) const { return this->val == myInt.val; } bool operator=(const MyInt &myInt) { this->val = myInt.val; //这里认为赋值总是正确的 return true; } private: int val; }; ostream& operator<<(ostream &out, const MyInt &myInt) { out << myInt.val; return out; } MyInt operator*(const MyInt &myInt1, const MyInt &myInt2) { return MyInt(myInt1.val * myInt2.val); } int main() { MyInt myInt1(100); MyInt myInt2(10); MyInt myInt3(10); if ((myInt2 * myInt3) = myInt1) { cout << "==" << endl; } else { cout << "!=" << endl; } return 0; }
上面这段程序虽然可以通过编译，但事与愿违，我们本来是要比较myInt2 * myInt3是否等于myInt1，不小心将==写成了=，结果他们总是相等的，因此，在重载*时，需要给返回值加上const（因为*计算结果是一个常量，尝试对常量赋值总是错误的，即使是自定义类型）：
friend const MyInt operator*(const MyInt &myInt1, const MyInt &myInt2); const MyInt operator*(const MyInt &myInt1, const MyInt &myInt2) { return MyInt(myInt1.val * myInt2.val); }
这时再进行赋值，编译器就会提示我们，是不是要进行比较运算，而不是赋值运算。
const也可以用来限定指针自身或指针所指物，比如这样一段程序：
char buf[] = "hello"; char other[] = "other"; int main() { char* p = buf; p[0] = 'a'; printf("%s\n", p); p = other; printf("%s\n", p); return 0; }
在p指针没有被修饰为const类型之前，我们可以随意改变指针所指物，以及指针指向。
当我们不想让指针所指物改变时就应该在*前面加上const限定：
const char* p = buf;
当我们不想让指针指向改变时就应该在*后面加上const限定：
char* const p = buf;
const char *p = buf; 和 char const *p = buf;等价。因此只需要记const和*的相对位置即可，与类型无关。
const也可以作用于成员函数，并且，一个函数如果只是常量性不同，是可以被重载的：
class Demo { public: Demo() { } void output() { cout << "non-const output" << endl; } void output() const { cout << "const ouput" << endl; } }; int main() { Demo non_const_demo; const Demo const_demo; non_const_demo.output(); const_demo.output(); return 0; }
上述程序，const类型的对象调用const类型的ouput，非const类型对象调用非const类型的ouput。需要注意的是：非const类型对象可以调用const类型的函数，而const类型对象不能调用非const类型的函数。
const又分为数据意义上的const和逻辑意义上的const。
数据意义上 的const是指如果一个成员函数已经声明为const，这时当在该函数内企图修改成员变量（static除外）时，被认为是非法的。也就是说，编译器在进行检查时，只会检查是否存在修改成员变量的赋值动作。但该函数是否真正是const的，编译器并不知道，比如：
class Demo { public: Demo(char *p) { this->p = p; } char& operator[](int pos) const { return p[pos]; } void output() const { printf("%s\n", p); } private: char *p; }; int main() { char buf[] = "hello"; const Demo demo(buf); demo.output(); demo[0] = 'a'; demo.output(); return 0; }
重载[]运算符，函数被const限定，意指该函数不会修改类的成员变量，但事实上，我们还是将其修改了，因为它返回了引用。这就是数据意义上的const，虽说编译器没报错，但并不是真正意义上的const函数。
而逻辑意义上的const，是指一个const成员函数可以修改它所处理的对象内的某些bits，但只有在客户端侦测不出的情况下才得如此。这其实也就是说该成员函数对外表现是const，而函数内部可能会修改成员变量。
具体，通过关键词mutable，mutable修饰的成员变量是可以在const成员函数内部修改的。
class Demo { public: Demo() {} void func() const { val = 5; } private: mutable int val; };
逻辑意义上的const，更多的是人为控制的，比如，一个成员函数被限定为const，对于使用者而言，放心大胆的使用即可，无需关注函数内部是否修改了成员变量，即使修改了，也应当是设计如此。
在写程序时应该使用逻辑意义上的常量性。
之前提到，非const类型可以调用const类型的成员函数，因此，在实现const和非const类型的两个版本时，可以通过非const类型调用const的方式减少代码重复。
来看一下书中的例子：
class TextBlock { public: const char& operator[](std::size_t position) const { return text[position]; } char& operator[](std::size_t position) { return const_cast<char &>(static_cast<const TextBlock&>(*this)[position]); } private: char *text; };
这里重载了const版本和非const版本的[]，非const版本调用const版本的逻辑处理部分。其中涉及两次转型动作，第一次，非const类型的对象需要转为const，从而调用const类型的[]，第二次，const类型的返回结果，需要通过const_cast来移除const限定。
