条款3 尽可能使用const

条款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限定。