Effective C++ Item 03: 尽可能使用 const-CSDN博客

Item 03: 尽可能使用 const

将某些东西声明为 const 可帮助编译器侦测出错误用法。const 可被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数本体。
编译器强制实施 bitwise constness, 但你编写程序时应该使用“概念上的常量性”。
当 const 和 non-const 成员函数有着实质等价的实现时，令 non-const 版本调用 const 版本可避免代码重复。

const 在语义上指定了“对象不该被改动”这一约束。这一约束可以带来许多好处，不但让编译器强制检查约束是否被满足，同时也警示程序员，某值应当保持不变，这在编程上可以避免许多没有必要的错误和漏洞。

const 用来修饰变量

const 几乎可以用来修饰所有变量，无论是全局的还是局部的，类内的还是类外的。用 const 修饰的变量不允许被改动。特别的，对指针变量而言，有指针变量本身能否被改动和指针所指之物能否被改动的区别，分别对应了顶层 const 和底层 const 。

const int a = 1;
int const a = 1; //对于普通变量，const的位置在类型前后的意义等价

char greeting[] = "Hello";
char* p = greeting;         //non-const pointer,non-const data
const char* p = greeting;   //non-const pointer,const data
char* const p = greeting;   //const pointer,non-const data
const char* const p = greeting; //const pointer,const data
char const* const p = greeting; //const pointer,const data
//对于指针变量而言，顶层const和底层const的区别在于出现在星号的那一边。
复制代码

需要注意的是，STL 迭代器形式上如 std::vector<int>::iterator 在指针基础上塑造出来的，它的作用就像个 T* 指针。将迭代器声明为 const 就跟声明指针为 const 一样（T* const），此时迭代器不可改变。如果希望迭代器所指之物不能被改变(const T*)，需要用到 const_iterator。

std::vector<int> vec;
const std::vector<int>::iterator iter = vec.begin();
*iter = 10; //ok
++iter;     //error

std::vector<int>::const_iterator cIter = vec.begin();
*cIter = 10; //error
++cIter;     //ok
复制代码

const 用来修饰函数的参数以及返回值

这本质上与 const 修饰普通变量的作用一致，但在修饰的变量时函数参数或返回值时起到很大的威力。
- 修饰函数的参数可以防止传入的参数在函数内部发生修改，特别是对于指针或引用类型的参数。对于这两种类型之外的变量，如 int ，则没必要用 const 修饰，因为采用复制传值并不会改变外部的传入参数。
- 修饰函数的返回值可以防止返回值被修改，同时也能防范一些低级错误。
```
class Rational{};
const Rational operator* (const Rational& lhs, const Rational& rhl);

Rational a, b, c;
(a * b) = c; //用const修饰返回值的话，这样的错误就能被立马侦查出来
复制代码
```
const 用来修饰成员函数

const 成员函数可以防止在函数内部修改成员变量（可以调用成员变量但不能修改)，同时也方式函数内部调用 non-const 成员函数，这保证了 const 成员函数不会改变对象的状态。

然而，编译器对 const 成员函数不修改对象状态执行的是 bitwise const ，并不能保证对象内部变量不会被改变。
```
class CTextBlock
{
public:
    char& operator[](std::size_t pos) const { return pText[pos];} //bitwise const声明
private:
    char* pText;
}
复制代码
```
此时，虽然 const 成员函数保证了不会修改对象的 pTest 变量，但它的引用返回值却可以在外部修改 pTest 的所指之物。这在逻辑上并非是 const 的。此外，一个 const 成员函数即使修改了对象的某些 bit, 它在逻辑上仍然是 const 的。譬如在 CTextBlock 这个类中，可能会高速缓存文本区块的长度以应付访问，这种数据的修改对 const CTextBlock 对象来说是可以接受的。
```
class CTextBlock
{
public:
    std::size_t length() const;
private:
    char* pText;
    std::size_t textLength;
    bool lengthIsValid;
}

std::size_t CTextBlock::length() const
{
    if (!lenghtIsValid)
    {
        textLength = std:strlen(pText); //error
        lenghtIsValid = true; //error
    }
    return textLength;
}
复制代码
```
解决这个问题的办法是引入与 const 相关的摆动场：mutable（可变的）。用 mutable 修饰的成员变量可以被 const 以及 non-const 成员变量同时修改。

需要注意的是，当类里面同时具有 const 和 non-const 两个版本的成员函数，它们实现相同的功能时，会带来代码的重复。此时可以使用 casting 这个技巧来避免。
```
class TextBlock
{
    public:
    const char& operator[](std::size_t pos) const
    {
        ...//边界检验，日志数据访问，检验数据完整性等共同操作
        return pText[pos];
    }
    char& operator[](std::size_t pos)
    {
        return const_cast<char&>(
            static_cast<const TextBlock&>(*this)[pos]
        );
    }
}
复制代码
```
在上述代码中，首先使用 static_cast 将对象转换成 const 对象以调用对象的 const 成员函数，再通过 const_cast 去掉返回值的 const 属性，即可实现这一技巧。