Effective C++(一): Const Correctness, Const成员函数和Const Cast

---

有关 const 的用法是 cpp 中一个非常经典且易错的部分，在面试和日常工作中各种各样的 const 经常让人摸不着头脑，今天就来根据 const 扮演的不同角色来归纳有关 const 的不同用法

一、Const成员函数

const 在成员函数中的用法可谓是面试必问题。一般来说会涉及到以下几点:
我们假设我们自己实现了一个 String 类并且重载了他的运算符[]:

class MyString {
public:
    MyString(const std::string& str) : text(str) {}

    // const版本的operator[]
    const char& operator[](std::size_t position) const {
        return text[position];
    }

    // non-const版本的operator[]
    char& operator[](std::size_t position) {
        return text[position];
    }

private:
    std::string text;
};

int main() { 
  MyString mutableString("Hello");
  const MyString constString("world");
  mutableString[0] = 'h'; //ok this could be modified 
  char ch = constString[0]; //ok, and here constString "uses" const char& operator[] because it is a const class.
  constString[0] = 'w'; //error. const char& could not be modified.报错信息如下:
  	/*
  		chapter2.cpp:28:18: error: cannot assign to return value because function 'operator[]' returns a const value
	  constString[0] = 'w'; //error. const char& could not be modified.
	  ~~~~~~~~~~~~~~ ^
	chapter2.cpp:10:11: note: function 'operator[]' which returns const-qualified type 'const char &' declared here
	    const char& operator[](std::size_t position) const {
	          ^~~~~
	1 error generated.
	*/
  return 0;
}

在这里我们可以清楚看到这两个函数的区别，第一个重载的运算符只能用在 const 对象上而第二个重载的运算符[] 只能用在非 const 对象上，同时第一个重载的运算符最后的 const 后缀非常重要，这意味着这个函数不会修改任何类中的成员变量(除了被标记为 mutable 的变量）。这个关键字让编译器知道，这个函数可以在 const 对象上调用。如果没有这个 const 后缀，函数就不能在 const 对象上调用。我们可以试着把这个 const 后缀删除，再次运行就会发现会报错。 报错信息如下:

chapter2.cpp:27:24: error: no viable overloaded operator[] for type 'const MyString'
  char ch = constString[0]; //ok, and here constString "uses" const char& operator[] because it is a const class.
            ~~~~~~~~~~~^~
chapter2.cpp:10:17: note: candidate function not viable: 'this' argument has type 'const MyString', but method is not marked const
    const char& operator[](std::size_t position) {
                ^
1 error generated.

二、Const Correctness

我们都知道被 const 修饰的变量绝大多数情况下是不能被修改的，然而，当我们的变量类型比较复杂，比如是一个指针的时候，如何判断常量指针还是指针常量呢？
下面是一些例子:

char greeting[] = "Hello";

// 指针可修改，数据可修改
char* p1 = greeting; 
p1[0] = 'h'; // 正确: 数据可修改
p1 = nullptr; // 正确: 指针可修改

// 指针可修改，数据不可修改
const char* p2 = greeting; 
// p2[0] = 'h'; // 错误: 数据不可修改
p2 = nullptr; // 正确: 指针可修改

char const* p22 = greeting;
//p22[0] = 'h'; //错误,数据不能被修改
p22 = nullptr //正确，指针可以修改

p2 和 p22 也叫做常量指针，即指针可以被修改但是数据不能被修改

// 指针不可修改，数据可修改
char* const p3 = greeting; 
p3[0] = 'h'; // 正确: 数据可修改
// p3 = nullptr; // 错误: 指针不可修改

p3 也叫做指针常量，即数据可以被修改，但是指针不能被修改

// 指针不可修改，数据不可修改
const char* const p4 = greeting; 
// p4[0] = 'h'; // 错误: 数据不可修改
// p4 = nullptr; // 错误: 指针不可修改

三、Const Cast

首先我们先来介绍一下我们为什么需要 const cast。
在第一个知识点中，我们看到对于同一个类对象的运算符重载函数，我们有两种形式，一种是作用于 const 类变量的，一种是作用于非 const 类变量的，这两个函数尽管有这不同的修饰符，但是他们的实现逻辑是一样的，这就造成了函数实现的冗余。在工程中，我们要么需要改变 const 运算符重载符函数的函数实现逻辑，要么改变非 const 运算符重载函数的函数实现逻辑。 一般来说我们会选择后者，因为在 C++中，const 变量拥有着比非 const 变量多的限制，如果我们选择将 const 变量转化为非 const 变量会带来更多的安全隐患。 因此，一般为了优化代码，我们会将非 const 对象中的运算符重载函数改为以下形式:

    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]);
    }

在这里，static_cast的作用是用来处理几乎所有类型转换的类型转换运算符，除了涉及底层的 const 转换。比如 int 到 float 的转换和派生类到基类之间的转换（注意基类到派生类的转换是不允许的） , 而 const_cast的作用是: 删除或者添加（极少数使用) 对象的 const 属性，这意味着当你拥有一个 const 对象但是你需要调用或者返回一个非 const 属性的时候，你需要通过const_cast抹除对象的 const 属性。 当然，你也可以使用 const_cast添加一个对象的 const 属性，但是这不常用，而且很容易出现各种奇怪的 bug。

---