const 使用总结

const 关键字是用于定义一个不该被改变的对象，它的作用是告诉编译器和其他程序员不允许修改这个对象的值或者状态。当程序员看到使用 const 修饰的代码时就知道不应该修改对应对象的值，而编译器则会强制实施这个约束，任何违反这个规定的代码会在编译期间报错。它可以用于任何函数或者类之后的全局或 namespace 的变量，也可以用于文件、函数、块作用域、类中的 static 变量，也可以用于修饰成员函数、函数的参数、模板参数。

const 对象的初始化

因为 const 对象一旦创建后就不能改变其值，所以 const 对象必须在定义时初始化。用来初始化它的对象无论是不是 const 对象都可以，也可以用它拷贝给另外一个非 const 对象。

const 对象仅在文件内有效

当你在文件中定义了这么一个 const 对象：

const int BufSize = 1024;

编译器在编译期间用到这个变量的话就会把它替换成对应的值，为了执行替换，编译器必须知道变量的初始值。如果程序中有多个文件定义了 const 对象，需要在编译期间获取这些 const 对象的值的话，有可能就会造成重复定义，为了避免重复定义的问题，默认情况下，const 对象被设定为仅在文件内有效，也就是说它的作用域仅限于在定义它的文件中的位置开始，直到文件结束，在其他文件是看不到这个对象的。

但是有时候我们确实是想在不同文件之间共享同一个变量，也就是只在一个文件中定义它，在其他文件里声明并使用它。解决的办法是，无论是在定义还是声明 const 对象时都添加 extern 关键字，这样就只需定义一次即可：

// file1.cc 定义并初始化一个const变量extern const int BufSize = 1024;// file1.h 声明BufSizeextern const int BufSize;

其他文件如果需要访问 BufSize 这个变量，只需包含 file1.h 这个头文件。

使用 const 替换 #define 来定义常量

尽最大的可能避免使用 #define 来编写任何代码，包括定义一个常量，可以使用 const 或者 C++11 中新增加的 constexpr，因为 #define 的处理发生在编译之前，在预处理阶段，这时语言的定义系统还没有参与进来，它会突破语言的一切规则，包括作用域，namespace、类型系统等，甚至不会产生符号，这对于编译出错时的问题定位和运行时的调试很不友好。

const 的引用

因为 C++不允许引用随意改变所绑定的对象，所以某种程度上来讲，引用也可以算是一种常量，那么在定义一个引用时必须绑定到一个对象上。当绑定到 const 对象时，我们称之为对常量的引用：

const int ci = 1024;const int &cr = ci;cr = 0;  // 错误，任何想通过cr改变引用对象的值都不允许

cosnt 的引用可以绑定到一个非 const 对象上，这时我们不能通过 const 的引用来修改引用对象的值，但可以通过其他的途径修改引用对象的值：

int i = 1024;const int &cr = i;cr = 512;      // 错误，不能通过cr改变其值i = 512；      // OK

我们可以使用非 const 对象来初始化 const 的引用，但是反过来却不行，我们不能使用 const 对象、const 的引用、字面值来初始化非 const 的引用：

int i = 1024;const int &cr = i;int &r = cr;	// 错误，丢失了const修饰符int &r = 1024;	// 错误，非const引用不允许绑定到字面值

const 和指针

与引用一样，指针也可以指向常量或非常量，指向常量的指针不能用于修改其所指对象的值，常量对象的地址只能存放于指向常量的指针中：

const int i = 1024;int *p = &i;		// 错误，不能存放常量的地址const int *cp = &i;	// OK*cp = 0;		// 错误，不能给*cp赋值

指向常量的指针没有规定一定要指向常量对象，允许它指向一个非常量对象，只是不能通过指针来修改所指对象的值。

int i = 1024;const int *p = &i;*p = 0;  // 错误，不能给*p赋值

和引用不一样的是，引用不是对象，而指针是对象，因此指针本身可以使用 const 修饰，这时指针本身就是一个 const 对象，称为常量指针。它必须在定义时被初始化，而且初始化之后就不能改变它的值，也就是说不能修改它所指的对象。虽然不能修改它所指的对象，但是它所指的对象的值却是可以修改，只要看它所指的对象的类型是什么，如果指向一个 const 对象，那么也是不允许修改的。指向一个 const 对象和指针是 const 对象可以同时存在，也可以只是其中的一种：

int i = 0， k = 0;const int j = 512;int *const pc = &i;	// 指针是const对象，不能修改为指向别的对象pc = &k;		// 错误，不允许修改const int *cp = &j;	// 指向const对象的指针const int *const cpc = &j;	// 指针是const对象，指向的对象也是const对象

我的记忆方法是从右向左阅读，向右结合，const 修饰离它右边最近的类型，如上面的例子，const cpc 结合，表示指针本身是 const 的。(const int *)结合，它和(int const )是一样的，int 类型符可以忽略，它可以是 double，也可以是自定义类型。这个 const 是修饰的，*代表是指针类型，所以表示它指向一个 const 对象。

顶层 const 和底层 const

顶层 const（top-level const）表示指针本身是个常量，底层 const（low-level const）表示所指的或所引用的对象是个常量。指针既可以是顶层 const 也可以是底层 const，而引用不是对象而且必须绑定到一个对象上，所以修饰引用的 const 都是底层 const。当执行对象的拷贝时，两者存在明显的差别。对于顶层的 const，可以忽略 const，因为拷出操作会复制一份新的值，不会影响它本身。对于底层 const 则不能忽略它的 const 限制，拷入和拷出的两个对象必须具有相同的 const 属性。

const int ci = 1024;int j = ci;		// OK，只是拷贝ci的值const int *cp = &j;const int *cp2 = cp;	// OKint *p = cp;		// 错误，会丢失*cp的const限制

使用 auto 自动类型推导时，auto 会忽略掉顶层的 const，而底层的 const 则会保留下来：

int i = 0;const int ci = i;const int &cr = ci;auto a = ci;		// a的类型是intauto b = cr;		// b的类型是int，只是拷贝cr引用对象的值auto c = &i;		// c的类型是int*auto d = &ci;		// d的类型是const int*，底层const不能忽略const auto e = cr;	// 当你希望auto推导出来的类型是const时，明确指出

当 auto 和引用一起使用时，初始值中的顶层 const 属性会被保留，因为引用是绑定这个对象的，相当于是这个对象的别名，所以这个对象的 const 属性应该要保留：

int i = 0;const int ci = 512;auto &r1 = i;		// r1是普通引用auto &r2 = ci;		// r2是const的引用r2 = 0;			// 错误，不能修改auto &ri = 512;		// 错误，非常量引用不能绑定到字面值const auto &ri = 0;	// OK 

decltype 处理顶层 const 和引用的方式和 auto 有些不同，顶层 const 和引用都会得到保留：

const int ci = 0;const int &cr = ci;decltype(ci) x = 512;	// x的类型是const intdecltype(cr) y = x;	// y的类型是const int&

const 用于函数参数

当 const 作用于函数的形参时，用实参初始化形参跟变量的初始化规则是一样的，细节可以参考以上几点。当形参定义为传值调用时，这时形参的 const 是顶层 const，顶层 const 在初始化时是可以被忽略的，它不能被用来判断函数是否重载，以下的代码实际上是相同的函数声明：

void fun(int i);void fun(const int i);  // 并非重载，跟第一个一样

当形参是指针或者引用时，这时的 const 是底层 const，这时 const 不能被忽略。可以使用常量实参或者非常量实参来初始化它都可以。可以根据形参中有没有 const 来区分函数是否重载：

class Object {  // ...};void fun(Object &obj);void fun(const Object &obj);  // 第二个函数是第一个的重载Object obj1;const Object obj2;fun(obj1);      // 调用的是第一个函数fun(obj2);      // 调用的是第二个函数

上面的代码中，根据实参是否是常量对象来调用相应的函数，当使用常量实参调用 fun 函数时，只能匹配到 const 版本的那个函数，当使用非常量实参调用 fun 函数时，上面两个函数都可以匹配到，但是非常量版本的函数更加精准匹配，所以编译器会选择第一个函数。对于形参是指针类型，也适用同样的规则。

除了内置类型，对于用户自定义类型，建议使用 const 的引用传递参数，不要使用传值方式。对于内置类型，还是建议使用传值方式，因为引用在底层一般是使用指针来实现，对于内置类型反而更浪费资源，而且编译器也可以做优化。对于自定义类型，一般情况下建议定义成 const 的引用，而不是普通的引用。定义成引用可以提高效率，避免大对象的拷贝。不要定义成普通的引用，因为这样会限制它的适用范围，比如别人的代码传下来的参数如果是 const 的，则不能使用，另外也不能给它传递字面值，这大大的限制了它的适用范围，而 cosnt 版本的则不存在问题。另外对于非 const 版本的引用参数，意味着在函数内部可以也可能会修改调用它的实参，这有时候不是你想要的。

const 用于成员函数

默认情况下，this 指针是指向类类型的非常量版本的常量指针，比如对于类型 class A{}; this 的类型相当于是 A* const，它只能指向非常量对象，如果我们定义了一个常量对象：const class A a; 这时 this 指针并不能指向常量对象 a；因为非常量指针不能指向常量对象。这就使得我们无法调用常量上的成员函数，为了解决这个问题，需要将 this 声明为指向常量的指针，即：const A* const this；但 this 指针是隐式的，我们无法直接声明它，解决方法就是将成员函数声明为 const 的，即在成员函数的参数列表之后加上 const 关键字，表示 this 是一个指向常量的指针，我们也这个成员函数为常量成员函数。

常量对象只能调用常量成员函数，也就是说不允许通过常量成员函数修改对象内部的数据或者状态，但有可能出现这种情况，常量成员函数虽然符合要求，因此欺骗过编译器而通过编译。

class A {public:  // 其它函数....
    char& operator[](int i) const {        return text[i];    }private:    char* text;};const A a;a[0] = 'a';

上面的代码中，成员函数 operator[]虽然定义为 const 的，但却返回一个引用，从而允许对返回结果进行赋值，这就违背了常量的本意，造成的后果是未定义行为。为了避免这个问题，我们对返回结果的类型也定义为 const 的：

const char& operator[](int i) const {  return text[i];}

但是对于非常量对象也限制了不能修改对象的值，我们通过成员函数是否有 const 来进行重载，这样，常量对象只能调用常量成员函数，非常量对象既可以调用常量成员函数也可以调用非常量成员函数，但是对于非常量成员函数更加匹配，所以会调用非常量成员函数，我们可以定义两个重载函数：

class A {public:  // 其它函数....
    const char& operator[](int i) const {        // 做其它的事情        // ...        return text[i];    }
  char& operator[](int i) {        // 做其它的事情        // ...        return text[i];    }private:    char* text;};
A a;a[0] = 'a';  // OK，调用非常量版本const A b;b[0] = 'b';  // 错误，返回常量引用不允许修改

当使用非常量对象时调用的是非常量版本的成员函数，当使用常量对象时调用的则是常量成员函数版本。但是又有另外的问题出现，这两个成员函数的函数体基本上是一模一样的，这样不仅造成代码的重复，而且维护起来也麻烦，假如要修改代码，就必须要同时修改两处地方，不然就可能造成不一致的地方。随着代码量越来越多，维护成本就随着增大。其实可以将他们共同的代码抽取出来封装成函数，然后分别调用它，这样只维护一处地方即可。

void do_something() {    // ....}const char& operator[](int i) const {    do_something();    return text[i];}char& operator[](int i) {    do_something();    return text[i];}

const 用于模板函数参数

对于函数模板，编译器利用实参来推断出模板实参，根据模板实参来生成一个函数实例。跟非模板函数不一样的是，模板函数一般不会进行类型转换，而是直接生成另外一个模板实例。但是对于 const 是个例外，它允许 const 进行类型转换。首先，对于顶层 const，无论是在实参中还是在形参中都会被忽略。其次对于底层 const，允许一个非 const 对象的引用或者指针转换为 const 对象的引用或者指针。

template <typename T>T f1(T t1, T t2) {  // ...}template <typename T>T& f2(const T& t1, const T& t2) {  // ...}std::string s1("string 1");std::string s2("string 2");const std::string s3("const string 3");const std::string s4("const string 4");f1(s1, s2);	// 实例化f1(string, string)f1(s1, s3);	// 实例化f1(string, string), s3的const被忽略f2(s1, s3);	// 实例化f2(const string&, const string&), s1被转换为const stringf2(s3, s4);	// 实例化f2(const string&, const string&)

前面的两个调用会生成同一个实例，因为是传值调用，实参会被拷贝，所以 const 会被忽略。后面两个调用会生成同一个实例，允许一个非 const 的引用转换为 const 的引用。

此篇文章同步发布于我的微信公众号： const 使用总结

如果您感兴趣这方面的内容，请在微信上搜索公众号 iShare 爱分享或者微信号 iTechShare 并关注，以便在内容更新时直接向您推送。

公众号：iShare爱分享