Effective C++ 之 Item 3：尽可能使用 const

Effective C++

Chapter 1. 让自己习惯C++（Accustoming Yourself to C++）

Item 3. 尽可能使用 const （Use const whenever possible）

1. const 与语义约束

const 允许指定一个语义约束（也就是指定一个“不该被改动”的对象），而编译器强制实施这项约束。它可以在 classes 外部修饰 global 或 namespace（见 Item2）作用域中的常量，或修饰文件、函数、或区块作用域（block scope）中被声明为 static 的对象。还可以修饰 classes 内部的 static 和 non-static 成员变量。面对指针，可以指出指针自身、指针所指物，或两者都（或都不）是 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

const 语法变化多端,但并不高深莫测。 如果关键字 const 出现在星号左边，表示被指物是常量；如果出现在星号右边，表示指针本身是常量；如果出现在星号两边，表示被指物和指针两者都是常量。

注意：如果被指物是常量,关键字 const 写在类型之前,与关键字写在类型之后/星号之前,两者写法的意义相同.即下列两个函数接受的参数类型是一样的:

void f1(const Widget* pw);                 // f1 获得一个指针，指向一个常量的（不变的）Widget 对象
void f2(Widget const * pw);                // f2 也是

2. const 与 STL 迭代器

STL 迭代器是以指针为根据塑模出来的，所以迭代器的作用就像个 T* 指针。声明迭代器为 const 就像声明指针为 const 一样（即声明一个 T* const 指针），表示迭代器不得指向不同的东西，但它所指东西的值是可以改动的。如果希望迭代器所指的东西不可被改动（即希望 STL 模拟一个 const T* 指针），你需要的是 const_iterator：

std::vector<int> vec;
...
const std::vector<int>::iterator iter = vec.begin();      // iter 的作用像个 T* const
*iter = 10;                                               // 没问题，改变 iter 所指物
++iter;                                                   // 错误！ iter 是 const
std::vector<int>::const_iterator cIter = vec.begin();     // cIter 的作用像个 const T*
*cIter = 10;                                              // 错误！ *cIter 是 const
++cIter;                                                  // 没问题，改变 cIter

3. const 与函数声明

const 最具威力的用法是面对函数声明时的应用。在一个函数声明式内， const 可以和函数返回值、各参数、函数自身（如果是成员函数）产生关联。令函数返回一个常量值，往往可以降低因客户错误而造成的意外，而又不至于放弃安全性和高效性。如有理数的 operator* 声明式：

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

返回一个 const 对象可以避免出现这样的行为:

Rational a, b, c;
...
(a * b) = c;            //在 a * b 的成果上调用 operator=

这种情况可能由打字错误（以及一个可被隐式转换为 bool 的类型）发生，却不易被发现：

if (a * b = c) ...              //其实是想做一个比较动作

至于 const 参数，它们不过像 local const 对象一样，应该在必要使用它们的时候使用它们。除非有需要改动参数或 local 对象，否则请将它们声明为 const 。

4. const 与成员函数

将 const 实施于成员函数的目的，是为了确认该成员函数可作用于 const 对象身上。这一类成员函数之所以重要，基于两个理由：

• 它们使 class 借口比较容易被理解。因为得知哪个函数可以改动对象内容而哪个函数不行很重要。
• 它们使“操作 const 对象”成为可能。这对编写高效代码很关键，因为改善 C++ 程序效率的一个根本办法是以 pass by reference-to-const 方式传递对象，而此技术可行的前提是有 const 成员函数可用来处理取得（并经修饰而成）的 const 对象。

两个成员函数如果只是常量性（constness）不同，可以被重载，这是一个重要的 C++ 特性。

class TextBlock
{
public:
    ...
    const char& operator[] (std::size_t position) const      // operator[] for const 对象
     { return text[position]; }
    char& operator[] (std::size_t position)                 // operator[] for non-const 对象
     { return text[position]; }
private:
    std::string text;
};

TextBlock 的 operator[]s 可以这么使用:

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

真实程序中 const 对象大多用于 passed by pointer-to-const 或 passed by reference-to-const 的传递结果。上述的 ctb 太过造作，下面这个比较真实：

void print(const TextBlock& ctb)   //此函数中 ctb 是 const
{
    std::cout << ctb[0];          //调用 const TextBlock::operator[]
    ...
}

只要重载 operator[] 并对不同的版本给予不同的返回类型,就可以令 const 和 non-const TextBlock 获得不同的处理:

std::cout << tb[0];             //没问题，读一个 non-const TextBlock
tb[0] = 'x';                    //没问题，写一个 non-const TextBlock
std::cout << ctb[0];            //没问题，读一个 const TextBlock
ctb[0] = 'x';                   //错误!! 写一个 const TextBlock, operator[]调用动作没问题,错在为函数返回的 const char& 进行赋值

注意 non-const operator[] 的返回类型是个 reference to char, 不是 char。如果 operator[] 只是返回一个 char,下面的句子就无法通过编译:

tb[0] = 'x';

因为如果函数的返回类型是个内置类型,改动函数返回值从来就不合法。纵使合法, C++ 以 by value 返回对象这一事实意味着被改动的其实是 tb.text[0] 的一个副本，不是其自身，这不会是你想要的。

成员函数如果是 const 意味着什么？有两个流行概念：bitwise constness（又称 physical constness）和（logical constness）。

bitwise const 阵营的人认为成员函数只有在不更改对象之任何成员变量（static 除外）时才可以说是 const 。也就是说它不更改对象内的任何一个bit。这种论点的好处是很容易侦测违反点：编译器只需寻找成员变量的赋值动作即可。bitwise constness 正是 C++ 对常量性（constness）的定义，因此 const 成员函数不可以更改对象内任何 non-static 成员变量。

但许多成员函数虽然不十足具备 const 性质却能通过 bitwise 测试。更具体地说，一个更改了”指针所指物“的成员函数虽然不能算是 const，但如果只有指针（而非其所指物）隶属于对象，那么称此函数为 bitwise const 不会引发编译器异议。这导致反直观结果。

class CTextBlock
{
public:
    ...
    char& operator[](std::size_t position) const    // bitwise const 声明，但其实不适当
    { return pText[position]; }
private:
    char* pText;
};

这个 class 不适当地将其 operator[] 声明为 const 成员函数,而该函数却返回一个 reference 指向对象内部值(详见 Item 28) 。假设暂时不管这个事实, operator[] 实现代码并不更改 pText, 它是 bitwise const, 编译器为 operator[] 产出目标码，但是:

const CTextBlock cctb("hello");         //声明一个常量对象
char* pc = &cctb[0];                    //调用 const operator[] 取得一个指针，指向 cctb 的数据
*pc = 'J';                              //cctb 现在有了 "Jello" 这样的内容

此处你创建一个常量对象并设以某值，而且只对它调用 const 成员函数。但你终究还是改变了它的值。

这种情况导出所谓的 logical constness 。这一派主张一个 const 成员函数可以修改它所处的对象内的某些 bits，但只有在客户端侦测不出的情况下得如此。例如 CTextBlock class 有可能告诉缓存（cache）文本区块的长度以便应付询问：

class CTextBlock
{
public:
    ...
    std::size_t length() const;
private:
    char* pText;
    std::size_t textLength;                  //最近一次计算的文本区块长度
     bool lengthIsValid;                      //目前的长度是否有效
};
std::size_t CTextBlock::length() const
{
    if (!lengthIsValid)
    {
        textLength = std::strlen(pText);     //错误！在 const 成员函数内不能赋值给 textLength 和 lengthIdValid。
         lengthIsVaild = true;
    }
    return textLength;
}

length 的实现不是 bitwise const，因为 textLength 和 lengthIsValid 都可能被修改。这两笔数据被修改对 const CTextBlock 对象而言虽然可接受，但编译器不同意，它们坚持 bitwise constness。解决之道是利用 C++ 的一个与 const 相关的摆动场：mutable（可变的）。mutable 释放掉 non-static 成员变量的 bitwise constness 约束：

class CTextBlock
{
public:
    ...
    std::size_t length() const;
private:
    char* pText;
    mutable std::size_t textLength;                 //这些成员变量可能总是会被修改，即使在 const 成员函数内。
    mutable bool lengthIsValid;
};
std::size_t CTextBlock::length() const
{
    if (!lengthIsValid)
    {
        textLength = std::strlen(pText);     //现在可以这样。
         lengthIsVaild = true;                //也可以这样。
    }
    return textLength;
}

在 const 和 non-const 成员函数中重复了一些代码，所以最佳的方式是实现 operator[] 的机能一次并使用它两次。也就是说，必须令其中一个调用另一个。这促使我们将常量性转除（casting sway constness） 。

例子中 const operator[] 完全做掉了 non-const 版本该做的一切，唯一的不同是其返回类型多了一个 const 资格修饰。这种情况下如果将返回值的 const 转除是安全的，因为不论谁调用 non-const operator[] 都一定先有个 non-const 对象，否则就不能够调用 non-const 函数。所以令 non-const operator[] 调用其 const 兄弟是一个避免代码重复的安全做法 —— 即使过程中需要一个转型动作。

class TextBlock
{
public:
    ...
    const char& operator[](std::size_t position) const
    {
        ...                        //边界检验（bounds checking）
         ...                        //志记数据访问（log access data）
         ...                        //检验数据完整性（verify data integrity）
        return text[position];
    }
    char& operator[](std::size_t position)       //现在只调用 const op[]
    {
        return const_cast<char&>( static_cast<const TextBlock&>(*this)[position] );   //将 op[] 返回值的 const 转除为 *this 加上 const

                                                                                      //调用 const op[]
    }
    ...
};

这份代码有两个转型动作，而不是一个，我们打算让 non-const operator[] 调用其 const 兄弟，但 non-const operator[] 内部若只是单纯调用 operator[] ，会递归调用自己。为了避免无穷递归，我们必须明确指出调用的是 const operator[] ，但 C++ 缺乏直接的语法可以这么做，因此这里将 *this 从其原型 TextBlock& 转型为 const TextBlock& 。所以这里有两次转型：

• 第一次用来为 *this 添加 const（这使接下来调用 operator[] 时得以调用 const 版本）；
• 第二次则是从 const operator[] 的返回值中移除 const 。

添加 const 的那一次转型强迫进行了一次安全转型（将 non-const 对象转为 const 对象），所以我们使用 static_cast 。移除 const 的那个动作只可以借由 const_cast 完成，没有其他选择。

更值得了解的是反向做法 —— 令 const 版本调用 non-const 版本以避免重复 —— 并不是你该做的事。记住， const 成员函数承诺绝不改变其对象的逻辑状态（logical state）， non-const 成员函数却没有这般承诺。如果在 const 函数内调用 non-const 函数，就是冒了这样的风险：你曾经承诺不改动的那个对象被改动了。

const 是个奇妙且非比寻常的东西。在指针和迭代器身上；在指针、迭代器及 reference 指涉的对象身上；在函数参数和返回类型身上；在 local 变量身上；在成员函数身上；······。尽可能使用它。

请记住：

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