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 C
        return text[position];
    }
    char& operator[](size_t position){
        //DO A
        //DO B
        //DO C
        return text[position];
    }
};

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

class TextBook{
private:
    string text;
public:
    const char& operator[](size_t position) const{
        //DO A
        //DO B
        //DO C
        return 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。

static_cast强迫隐式转换，为*this加上const

const_cast 将返回值的const char& 的const去掉

运用 const 成员函数实现出其 non-const 孪生兄弟 的技术。而反向做法，“const成员函数调用non-const成员函数”是一种错误行为！