作用

1. 修饰变量，说明该变量不可改变
2. 修饰指针，分为指向指针的常量 (pointer to const) 和 自身是常量的指针 (const pointer)
3. 修饰引用，指向常量的引用 (reference to const)
4. 修饰成员函数，说明该成员函数内不能修改成员变量

示例

修饰变量

const double PAI = 3.141592653589793;
// PAI = 6.666; // 编译报错，const 修饰的变量不可改变，相当于一个有名字的常量

修饰指向常量的指针

可以修改指针指向的地址，不能修改指针指向的地址的值

int a = 5;
int b = 4;
const int *c = &a; // 指针变量，指向 int 类型的常量

// *c = 2;  // 编译报错, 指针指向 int 类型的常量，不能修改指针指向的常量的值
c = &b;

cout << "a = " << a << endl; // 输出 a = 5
cout << "c = " << *c << endl; // 输出 c = 4

int a = 5;
int b = 4;
int const *c = &a; // 也是指针变量，因为 *c 表示的是指针指向的值

// *c = 2; // 编译报错, 指针指向 int 类型的常量，不能修改指针指向的常量的
c = &b;

cout << "a = " << a << endl; // 输出 a = 5
cout << "c = " << *c << endl; // 输出 c = 4

修饰自身是常量的指针

可以修改指针指向的地址的值，不能修改指针指向的地址

int a = 5;
int b = 4;
int* const c = &a; // 指针常量，指向 int 类型变量

*c = 2;
// c = &b; // 编译报错，指针是常量，不能修改指针的值

cout << "a = " << a << endl; // 输出 a = 2, 因为 c 和 a 指向同一个地址，修改了 *c 和 *a 表示同一个值
cout << "c = " << *c << endl; // 输出 c = 2

修饰指向常量的引用

引用是对象的别名，声明时就要初始化，初始化之后就不能再改变指向，所以不存在常引用的说法，只有指向常量的引用。

int a = 5;
const int &b = a; 
// int const &b = a;  // 效果一样
// int& const b = a;  // 效果一样

//  b = 3; // 编译报错，不能修改引用的对象的值

cout << b << endl; // 输出 5

修饰成员函数

class test  {
public:
    int get() const; // 常成员函数，在 get() 里不能修改 test 类成员变量的值，除非成员变量用 mutable 修饰

private:
    const int a; // 常对象成员，只能类内初始化或初始化列表初始化，初始化之后值不能修改
    mutable int b; // 在任何地方都可以修改变量的值
};

int main() {
    test t1; // 普通对象，可以调用全部成员函数
    const test t2; // 常对象，只能调用长成员函数
}

总结

所有的用法其实都被4个作用概括了，理解透了，无论出现在哪里都能知道表示的是什么。

可以这样记忆：const 后面跟着什么，什么的值就不能改变。