const关键字
经常会在程序中看到const关键字，const是constant的缩写，意为不变。
const在C++中可以用来修饰内置类型变量、自定义对象、成员函数、返回值、函数参数
1、const修饰普通类型变量
const int x = 7;
int y = x; //正确定义并赋值
x = 5; //错误，x为const类型，即常量，不允许修改x
**2、const修饰指针变量 ** （左定值，右定向）
①const修饰指针指向的内容，则内容不可变。即让指针指向一个常量对象，这样可以防止指针来修改所指向的值。
②const修饰指针本身，防止改变指针指向的位置。
例如：
int age = 27;
const int * p = &age; //const在*的左侧，左定值
//属于第一种情况，该声明指出p指向一个const int(这里为27),因此不能使用p来修改这个值，换句话说*p的值为const，不能被修改。
*p += 1; //invalid
cin >> *p; //invalid
以上指针p的声明并不意味着它指向的值实际上就是一个常量，而只是意味着对p而言，这个值是常量。
再看第二种情况，const修饰指针：
int age = 18;
int* const p = &age; //const在*的右侧，右定向
*p = 17; //正确
int age2 = 27;
p = &age2; //error const指针p，其指向的地址不能改变，但是内容可以改变。
另外需要注意：
const float money = 9.8;
const float *pm = &money; //valid
const float fee = 5.7;
float *pf = &fee; //invalid
//将fee的地址赋给pf，说明可以使用pf来修改fee的值，这使得fee的const状态很荒谬
3、const修饰参数传递 只读
const修饰函数参数主要有：
①值传递的const修饰传递，一般这种不需要const修饰，因为值传递时函数会自动产生临时变量来赋值实参值。
#include<iostream>
using namespace std;
void printValue(const int a)
{
cout<<a;
// ++a; 错误，a的值不能被改变
}
int main()
{
printValue(8);
system("pause");
return 0;
}
②当const参数为指针时，可以防止指针被意外篡改
#include<iostream>
using namespace std;
void printValue(int *const a)
{
cout<<*a<<" ";
*a = 9;
}
int main()
{
int a = 8;
printValue(&a);
cout<<a; // a 为 9
system("pause");
return 0;
}
③自定义类型的参数传递，需要临时对象复制参数，对于临时对象的构造，需要调用构造函数，比较浪费时间，因此我们采取 const 外加引用传递的方法。
并且对于一般的 int、double 等内置类型，我们不采用引用的传递方式。
#include<iostream>
using namespace std;
class Test
{
public:
Test(){}
Test(int _m):_cm(_m){}
int get_cm()const
{
return _cm;
}
private:
int _cm;
};
void print(const Test& _tt)
{
cout<<_tt.get_cm();
}
int main(void)
{
Test t(8);
print(t);
system("pause");
return 0;
}
4、const修饰函数返回值
①const 修饰内置类型的返回值，修饰与不修饰返回值作用一样。
#include<iostream>
using namespace std;
const int returnV1()
{
return 1;
}
int returnV2()
{
return 0;
}
int main(void)
{
int m = returnV1();
int n = returnV2();
cout << m << " " << n << endl;
system("pause");
return 0;
}
② const 修饰自定义类型的作为返回值，此时返回的值不能作为左值使用，既不能被赋值，也不能被修改。
③const 修饰返回的指针或者引用。
5、const修饰类成员函数
const 修饰类成员函数，是为了防止成员函数修改被调用对象的值，如果我们不想修改一个调用对象的值，所有的成员函数都应当声明为 const 成员函数。
**注意：**const 关键字不能与 static 关键字同时使用，因为 static 关键字修饰静态成员函数，静态成员函数不含有 this 指针，即不能实例化，const 成员函数必须具体到某一实例。
下面的 get_cm()const; 函数用到了 const 成员函数：
#include<iostream>
using namespace std;
class Test
{
public:
Test(){}
Test(int _m):_cm(_m){}
int get_cm()const
{
return _cm;
}
private:
int _cm;
};
void print(const Test& _tt)
{
cout<<_tt.get_cm();
}
int main()
{
Test t(8);
print(t);
system("pause");
return 0;
}
如果 get_cm() 去掉 const 修饰，则 print传递的 const _tt 即使没有改变对象的值，编译器也认为函数会改变对象的值，所以我们尽量按照要求将所有的不需要改变对象内容的函数都作为 const 成员函数。
如果有个成员函数想修改对象中的某一个成员怎么办，此时可以使用 mutable 关键字修饰这个成员，mutable 的意思也是易变的，容易改变的意思，被 mutable 关键字修饰的成员可以处于不断变化中，如下：
#include<iostream>
using namespace std;
class Test
{
public:
Test(int _m,int _t):_cm(_m),_ct(_t){}
void Kf()const
{
++_cm; // 错误
++_ct; // 正确
}
private:
int _cm;
mutable int _ct;
};
int main(void)
{
Test t(8,7);
return 0;
}
原文https://www.cnblogs.com/Forever-Kenlen-Ja/p/3776991.html
参考：C++ primer plus