Effective C++——尽可能使用const

const允许指定一个语义约束（也就是指定一个“不该被改动”的对象），而编译器会强制实施这项约束。只要保持某个值不变是事实，就应该说出来。以获得编译器的协助，保证不被违反。

const与指针

注意const的写法，

const char* p = ...;//p可以指向新的地址，但是不能通过*p修改值
char* const p = ...;//可以通过*p修改值，但是不能让p指向新的地址

void f1(const Widget* pw);
void f2(Widget const * pw);//两种写法是一样的

STL的迭代器，以指针为根据，所以迭代器的作用就像个T*的指针。声明迭代器为const就像声明指针为const一样，表示这个迭代器不能指向不同的东西，但它所指的东西的值是可以改动的。

vector<int> vec;const vector<int>::iterator iter = vec.begin();//iter相当于一个T* const
*iter = 10;//可以，相当于改变*p的值
iter++;    //错误！
vector<int>::const_iterator cIter = vec.begin();//cIter相当于const T*
*cIter = 10;//错误！
cIter++;    //可以

注：关于auto关键字声明

for (auto it = myVector.begin(); it != myVector.end(); ++it) {// 使用 iterator
}for (auto it = myVector.cbegin(); it != myVector.cend(); ++it) {// 使用 const_iterator
}

const与函数声明

返回一个const

令函数返回一个常量值，例如，

const int operator*(const MyClass& m1, const MyClass& m2);

为什么要返回一个常量呢？考虑如下情景

MyClass a,b,c;
if (a*b = c){...}

在本来应该是判断的过程中，变成了一个赋值过程，而且极大可能返回一个true。如果我们令a*b返回一个const值，就可以避免这种错误的发生（编译就不会通过，尽早发现错误）。

const成员函数

将const实施于成员函数的目的，是为了确认该成员函数可以作用于const对象身上。第一，它们使class接口容易理解。方便得知哪个函数可以改动对象内容而哪个函数不行。第二，它们使“操作const对象”成为可能。

一个容易被忽视的事实是：两个成员函数如果只是常量性不同，可以被重载。

class TextBook{
private:string text;
public:const char& operator[](size_t position) const{ return text[position];}char& operator[](size_t position){ return text[position];}
};

其中，const的方法可以被const对象调用。例如，

void print(const TextBook& tb){...cout << tb[0];...
}

注，
const void f(...) const;
第一个const说明函数的返回值是const，第二个const声明f函数不会修改对象值，可以被const对象调用（但可以修改static成员变量）

mutable关键字

mutable修饰的non-static成员变量，在const成员函数中也可以修改其值。（某些场景可能确实需要如此）

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

如果，一个代码量很多的成员函数，同时需要一个const版本也需要一个non-const版本，则必然会出现大量的重复代码。

class TextBook{
private:string text;
public:const char& operator[](size_t position) const{//DO A//DO B//DO Creturn text[position];}char& operator[](size_t position){//DO A//DO B//DO Creturn text[position];}
};

在上面的代码中，const 版本做到了 non-const 版本的一切，除了一个const资格修饰。我们将代码做如下修改：

class TextBook{
private:string text;
public:const char& operator[](size_t position) const{//DO A//DO B//DO Creturn text[position];}char& operator[](size_t position){return const_cast<char&>(static_cast<const TextBook&>(*this)[position]);}
};

这份代码有两个转型动作，而不是一个。我们让 non-const 调用 const，但 non-const 内部如果单纯调用operator[]，会递归调用自己。所以，为了避免无穷的递归，我们必须明确指出调用的是const operator[]，但C++没有明确的语法可以这么做。因此，将 (*this) 从原始类型转型为 const TextBook& ，调用operator[]后，再将返回值中移除 const。