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 声明BufSize
extern 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; // OK
int *p = cp; // 错误，会丢失*cp的const限制
使用auto自动类型推导时，auto会忽略掉顶层的const，而底层的const则会保留下来：
int i = 0;
const int ci = i;
const int &cr = ci;
auto a = ci; // a的类型是int
auto 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 int
decltype(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 string
f2(s3, s4); // 实例化f2(const string&, const string&)
前面的两个调用会生成同一个实例，因为是传值调用，实参会被拷贝，所以const会被忽略。后面两个调用会生成同一个实例，允许一个非const的引用转换为const的引用。
