Effective C++--条款03：尽可能使用const

对指针的const：

如果const出现在*左端，表示被指物为常量，如果const出现在*右端，说明指针自身为常量。

例如：

    int b = 9;
    int a = 88;
    const int* p1 = &b;  //被指向的b为常量，即不能通过*p1 来修改b的值，但可以直接修改b的值;
    int* const p2 = &b;   //指针p2为常量，可以通过*p来修改b的值，但是指针p2的值不可被修改，就是说p2只能只想b;
    p1 = &a;          //正确
    p2 = &a;          //错误
    *p1 = 10;         //错误
    *p2 = 10;         //正确
    a = 1000;         //正确

一下两种写法是一样的都有人用，所以要习惯它们：

void f1(const int* a);
void f2(int const * a);

在STL中，迭代器的作用就像个T*指针。

std::vector<int> vec;
//...
const std::vector<int>::iterator iter = vec.begin(); //iter的作用类似T* const
*iter = 10; //正确
++iter;     //错误
std::vector<int>::const_iterator cIter = vec.begin(); //cIter的作用类似const T*
*cIter = 10;//错误
++cIter;    //正确

将函数返回值声明为const的作用：

例如有一个Rational类：

class Rational
{
    //...
};
const Rational operator* (const Rational& lhs, const Rational& rhs);

将上述重载*操作符的函数返回值设为const可以避免如下的错误操作：

if(a*b = c)  //本来想写if(a*b == c)

如果没有const，编译器是不会对上述代码报错的。

const 成员函数：

将成员函数声明为const，是为了确认该成员可作用于const对象身上。

1.可以使我们知道那个函数可以修改对象，哪个不行。
2. 使得操作const对象成为可能。

如果两个成员函数只是常量姓不同，可以被重载，不同类型的对象就会调用不同类型的成员函数。

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

TextBlocks tb("Hello");
std::cout << tb[0];      //调用non-const TextBlock::operator[]
const TextBlock ctb("World");
std::cout << ctb[0];     //调用const TextBlock::operator[]

另外的一个例子：

void print(const TextBlocks& ctb)
{
    std::cout << ctb[0]; //调用const TextBlock::operator[]
    //...
}