c++ const的使用

const是用来声明一个常量的，当你不想让一个值被改变时就用const,
const int max && int const max 是没有区别的，都可以。
不涉及到指针const很好理解。

涉及到指针的情况：

conat int b=100;    顶层const
int const c=11;    顶层const

const int *a=&b;    底层const 
[1] const控制（指针 * ）*a不能进行赋值操作 *a=3（错误）但可以修改a的存储的地址 a=&c
 
int const *a=&b; 底层const 
[2] const控制（指针 * ）*a不能进行赋值操作 *a=3（错误）但可以修改a的存储的地址 a=&c

int *const a=&b; 顶层const 
[3] const控制（变量）a，不能进行赋值操作 a=3，a++（错误）但可以修改*a保存b的值 *a=10
 
const int *const a =&b; 底层和顶层const 
[4]从右往左看const，右边的const 控制了a ，左边的 const控制*a，所以这里的2个const 不能改变本身，也不能改变所保存的地址。

 

 

const初始化
const的特点：
● 用const加以限定的变量，无法改变。
● 由于const对象定义之后就无法改变，所以必须对其进行初始化。
● const对象的常量特征仅在尝试改变它的时候表现出来，其他时候和变量无异。
const初始化：
const int bufSize = 512; //bufSize无法再改变
const仅在本文件中有效
const对象通常只在本文件内有效，如果希望其在其他文件中也有效，则需要在其前面加上extern关键字。更详细的做法是，在一个文件中定义const，在其他多个文件中声明并使用它。
extern const int bufSize = 512;
顶层const和底层const
首先，const是一个限定符，被它修饰的变量的值不能改变。对于一般的变量来说，其实没有顶层const和底层const的区别，而只有对于指针这类复合类型的基本变量，才有这样的区别。
如何区分顶层const和底层const？
顶层const表示指针本身是个常量；
底层const表示指针所指向的对象是个常量。
指针如果添加const修饰符时有两种情况：
● 指向常量的指针：代表不能改变其指向内容的指针。声明时const可以放在类型名前后都可，拿int类型来说，声明时：const int和int const 是等价的。声明指向常量的指针也就是底层const，下面举一个例子：
int num_a = 1;
int const *p_a = &num_a; //等价于const int *p_a = &num_a,指向const int 类型的指针，是底层const
//*p_a = 2; //错误，指向“常量”的指针不能改变所指的对象
注意：指向“常量”的指针不代表它所指向的内容一定是常量，只是代表不能通过解引用符（操作符*）来改变它所指向的内容。
上例中指针p_a指向的内容就不是常量，可以通过赋值语句：num_a=2; 来改变它所指向的内容。
● 常量指针：代表指针本身是常量，声明时必须初始化，之后它存储的地址值就不能再改变。声明时const必须放在指针符号后面，即：const 。声明常量指针就是顶层const，下面举一个例子：
int num_b = 2;
int *const p_b = &num_b; //指向int类型的const指针，是顶层const
//p_b = &num_a; //错误，常量指针不能改变存储的地址值
其实顶层const和底层const很简单，一个指针本身添加const限定符就是顶层const，而指针所指的对象添加const限定符就是底层const。
区分顶层const和底层const的作用
为啥非要区分顶层const和底层const呢，根据C++primer的解释，区分后有两个作用。
1 执行对象拷贝时有限制，常量的底层const不能赋值给非常量的底层const。也就是说，你只要能正确区分顶层const和底层const，你就能避免这样的赋值错误。下面举一个例子：
int num_c = 3;
const int *p_c = &num_c; //指向const int的指针，是底层指针
//int *p_d = p_c; //错误，不能将底层const指针赋值给非顶层const指针
const int *p_d = p_c; //正确，都是指向const int的指针
2 使用命名的强制类型转换函数const_cast时，需要能够分辨底层const和顶层const，因为const_cast只能改变运算对象的底层const。下面举一个例子：
int num_e = 4;
const int *p_e = &num_e;
//*p_e = 5; //错误，不能改变底层const指针指向的内容
int *p_f = const_cast<int *>(p_e); //正确，const_cast可以改变运算对象的底层const。但是使用时一定要知道num_e不是const的类型。
*p_f = 5; //正确，非顶层const指针可以改变指向的内容
cout << num_e; //输出5
3练习
说了这么多，应该练习一下，const int constconst* pppi 是顶层const还是底层const？
答案当然是底层const，因为int前面const限定符，而最后一个*后面没有const限定符。看最后一个例子：
const int a = 1; //a是顶层const
//int * pi = &a; //错误，&a是底层const，不能赋值给非底层const
const int * pi = &a; //正确，&a是底层const，可以赋值给底层const
const int *const *const ppi = &pi //即是底层const，也是顶层const
const int *const *const *pppi = &ppi; //底层const
指针和const限定符（另一版本理解方法）
● 指向const对象的指针
● const指针
● 指向const对象的const指针
const double *p;// 指向const double类型的指针
double *const p = &pi; //指向double对象的const指针
const double *const p = &pi;//指向const对象的const指针
下面看几个例子：
指向const对象的指针

#include<iostream>
using namespace std;
int main()
{
　　double a = 1.2;
　　double *p = &a; //p是指向变量a的指针

　　const double pi = 3.14;
　　//p = π//错，要想指向一个const对象，必须用指向const对象的指针
　　const double *cptr = π //const double类型的指针
　　//*cptr = 1.5; //错，指向const对象的指针只能指向const对象，因而不能修改其值

　　system("pause");
}
const指针
指向const对象的const指针
#include<iostream>
using namespace std;
int main()
{
　　double a = 1.2;
　　double *p = &a; //p是指向变量a的指针

　　const double pi = 3.14;
　　//p = π//错，要想指向一个const对象，必须用指向const对象的指针
　　const double *cptr = π
　　cptr = &a; //指向const对象的指针也能指向非const对象
　　//*cptr = 1.5; //但是不能通过指针对其进行修改

　　int errNum = 0;
　　int *const curErr = &errNum; //指向int对象的const指针，必须进行初始化，而且该const指针不能再指向其他对象

　　const double *const pi_ptr = π //指向const double对象的const指针
　　//不可以再指向其他的对象，而且也不可以通过指针修改对象的值

　　system("pause");
}

 

const写在左边也行，写在右边也行。
const string str1;
string const str2;
上面的两种写法都是对的。