《Effective C++》 rule 03: Use const whenever possible

const 可以修饰哪些东西？

  • const 可以修饰全局 (global) 或命名空间 (namespace) 或类外部的常量.

  • const 也可以修饰文件、函数或作用域中（block scope）被声明为 static 的对象.

  • const 还可以修饰类内部的静态 (static) 和非静态 (non-static) 成员变量.

  • const 与指针结合时，const 既可以修饰指针本身，也可以修饰指针所指对象.

    • 当 const 在 * 左边时，表示指针指向的对象是常量.
    • 当 const 在 * 右边时，表示指针本身是常量（即指针始终指向这个对象）.
    • 当 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（指针本身和指针所指对象都是常量）

    PS：有时 const 不一定写在对象类型之前，而是在对象类型和 *之间，这也能用来表示指针所指对象是常量.

    例如：

    void f1(const Widget* pw); void f2(Widget const* pw);

    这两种写法等价，都表示 pw 指向的是一个 const Widget* 对象.

STL 迭代器与指针

迭代器的作用就像是一个 T* 指针！

有一个需要注意的地方：声明一个迭代器为 const 时，实际上是相当于 T* const 指针.

  • 即，指针自身是常量，而指针所指对象实际上是可以改变的！

而如果我们想表示指针所指对象为常量，则需要使用 const _iterator.

例：

std::vector<int> vec; ...  // 相当于 T* const const std::vector<int>::iterator iter = vec.begin();		// 即 iter 本身是常量 *iter = 10;		// 没问题，修改迭代器指向的对象 ++iter;			// 错误：迭代器是个常量  // 相当于 const T* std::vector<int>::const_iterator cIter = vec.begin();		// 即 iter 所指对象是常量 *cIter = 10; 	// 错误：iter 所指对象是常量 ++cIter;		// 没问题，修改迭代器指向的对象

尽量多使用 const

对于函数返回值，如果没有修改参数或局部变量的需要，就应该将它的返回值声明为 const

这样的目的主要是为了安全，防止程序员因为失误对不该修改的函数返回值、参数或对象进行修改.

const 成员函数

Q：为什么要有 const 成员函数？

A：原因有二.

  1. 这样可以知道函数可以改变对象内容.
  2. 这样可以 操作 const 对象.

一个重要的 C++ 特性

两个成员函数，如果只是常量性（constness）不同，是可以被重载的！

也就是说，对于同样的一种“操作”，可以有处理 const 对象和 non-const 对象的两套逻辑.

看一个例子，有个类 TextBlock，用来表示一段文字：

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

对于 operator[]，可以这么调用：

TextBlock tb(Hello); std::cout << tb[0];				// 调用 non-const 对象版本的 operator[] const TextBlock ctb(World); std::cout << ctb[0];			// 调用 const 对象版本的 operator[]

还有一种更常见的调用 const 对象版本函数/运算符的例子：

void print(const TextBlock& ctb) {		     std::cout << ctb[0];		// 调用 const 对象版本的 operator[], 即 const TextBlock::operator[] }

重载的两个版本的函数，主要的区别就是，处理 const 对象的版本的函数不可以修改对象（很好理解，因为对象是 const 的嘛）：

std::cout << tb[0];				// 没问题，读一个 non-const 对象 tb[0] = 'x';				    // 没问题，修改一个 non-const 对象 std::cout << ctb[0];			// 没问题，读一个 const 对象 ctb[0] = 'x';					// 有问题！不能修改一个 const 对象

这里还有一个要注意的点：non-const operator[] 的返回值类型是 char& 而不是 char.

  • 如果返回值类型是 char，则语句 tb[0] = 'x'; 无法通过编译.
    • 因为 char 是内置类型，如果函数的返回值是个内置类型，那么修改函数返回值是不合法的！
  • 因为我们要修改对象，所以得传递引用（pass by reference），否则只是修改一个副本，没法起到修改对象的作用.

bitwise constness (physical constness) 和 logical constness

bitwise constness: 成员函数只有不修改对象的任何成员变量（当然 static 成员变量除外）时才可以声明为 const.

也就是说，bitwise constness 没有修改对象中的任何一个 bit （所以叫 bitwise constness）.

这其实也是 const 本身的定义. 即没有对修饰的对象内的任何 non-static 成员变量进行修改.

What's wrong with bitwise constness?

bitwise constness 有个问题.

考虑这样一种情况：

  • 类中有个指针对象，一个 bitwise constness 的成员函数没有修改这个指针对象.
  • 不过，这个指针指向的对象不属于这个类.
  • 因此，在这个 bitwise constness 的成员函数中有可能会对这个指针所指对象进行了修改.
  • 不过这也是完全合法的（编译通过），因为理论上这个指针所指对象并不属于这个类（只有这个指针属于中这个类），而这里只是对指针所指对象进行修改（而没有修改指针本身），因此是完全 ok 的.

例子：

class CTextBook { public:     ...     char& operator[] (std::size_t position) const {		// bitwise const 声明         return pText[position];     }  private:     char* pText; }

注意，这里的返回值是 char&，是个引用，所以有可能会修改指针所指对象的值.

  • 然而，这里并没有修改 pText 这个指针，因此编译器认为这个成员函数声明为 const 没有问题.

而正如刚才所说，这里是可以修改指针所指对象的值的：

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

语法上，上面的代码并没有问题. 指针 pc 并没有修改，只修改了 pc 指向的对象 cctb, 而 cctb 并不属于 CTextBook，所以 operator[]是符合一个 const 成员函数的要求滴~

但是逻辑上，这里还是产生了一些 意外的修改. 于是乎便有了 logical constness

logical constness

logical constness 与 bitwise constness 的不同在于: logical constness 不在乎是否（物理上）修改了类对象的 bits, 它的关注点在逻辑上是否有 产生修改 （不管修改的是什么）.

  • 换句话说，logical constness 允许（物理上）修改类对象，而主要保证逻辑上不要产生错误的修改.

考虑刚才的 CTextBook 例子，我们可能有这样一个需求：缓存文本的长度，并根据缓存的长度去读这段文本.
那么有如下代码:

class CTextBook { public:     ...     std::size_t length() const; private:     char* pText;     std::size_t textLength;			// 缓存的已读的文本的长度     bool lengthIsValid;				// 判断当前长度是否有效（文本是否还可以继续读） };  std::size_t CTextBook::length() const {     if (!lengthIsValid) {         textLength = std::strlen(pText);         lengthIsValid = true;     } }

当然，这段代码会报错，因为尝试在 一个 const 成员函数 CTextBook::length() 内修改类 CTextBook 的两个成员变量 textLength 和 lengthIsValid.

解决办法是：使用 mutable 关键字释放掉 non-static 成员变量的 bitwise constness 约束:

class CTextBook { public:     ...     std::size_t length() const; private:     char* pText;     // 声明：即使在 const 成员函数内，这两个成员变量也有可能会被修改     mutable std::size_t textLength;			     mutable bool lengthIsValid;				 };  std::size_t CTextBook::length() const {     if (!lengthIsValid) {				// 在 const 成员函数内修改 mutable 成员变量，没问题         textLength = std::strlen(pText);         lengthIsValid = true;     } }

这里，（物理上）修改了类对象的 non-static 对象，而保证了逻辑上没有错误的修改，这就是 logical constness.

在 const 和 non-const 成员函数中避免重复

前面提到了：两个成员函数，如果只是常量性（constness）不同，是可以被重载的！

那么对于重载的这两个函数，里面可能有大量的重复代码：

class TextBook { public:     ...     cosnt char& operator[] (std::size_t position) const {         ...				// 边界检查（bounds checkint）         ...				// 访问日志数据（log access data）         ...				// 校验数据完整性（verify data integrity）         return text[position];     }     char& operator[] (std::size_t position) {         ...				// 边界检查（bounds checkint）         ...				// 访问日志数据（log access data）         ...				// 校验数据完整性（verify data integrity）         return text[position];     } private:     std::string text; };

显然，这里对于 constness 不同的函数的重载导致了很多代码重复，这会带来很多问题——比如：

  • 不好维护
  • 代码量膨胀
  • 编译时间增长

解决办法：casting away constness

一句话概括：在处理 非const 对象版本的函数中调用处理 const 对象版本的函数。

  • 这样，同样的代码只写了一份.

上面的例子可以改成这样：

class TextBook { public:     ...     // 处理 const 对象版本的函数还是原来的样子     cosnt char& operator[] (std::size_t position) const {         ...				// 边界检查（bounds checkint）         ...				// 访问日志数据（log access data）         ...				// 校验数据完整性（verify data integrity）         return text[position];     }     // 处理 非const 对象版本的函数调用 const char& operatorp[]     char& operator[] (std::size_t position) {         /*         	这里的 const_cast 的作用是为了去调用 const op[]    			而 static_cast 的作用则是消除了 调用的 op[] 的 constness         */         return const_cast<char&>(static_cast<const TextBlock&>(*this)[position]);     } private:     std::string text; };

这样，通过将 const_cast 和 static_cast 结合，就实现了用 const 成员函数实现 非const 成员函数，避免了代码重复！

总结

  • 尽量多使用 const，const 可以帮助编译器检查一些错误用法（比如不该被修改的数据等）.
  • const 可以施加在任何作用域内的对象、函数参数、函数返回类型、成员函数.
  • 编译器在语法上做的检查时 bitwise constness，而实际编写程序时我们应该用 logical constness（必要时使用 mutable）.
  • 当 const 成员函数和 non-const 成员函数有着实质上等价的实现时，为了避免代码重复，可以使用 const_cast 结合 static_const. 从而在 非const 成员函数中调用 const 成员函数.