const 用法总结

　　在编程中我们常常会使用敞亮的概念，除了使用#define定义的宏之外，我们还有更好的选择，就是使用const关键字。

　　1.const关键字的意义

　　当我们定义一个变量，并且希望这个变量不再改变（编译器会做出优化），通常就会使用const限定符。

1     const int i = 3;//定义i==3的int常量i
2     i = 4;             //非法操作，i是场量，值不可以更改

　　定义一个常量时，必须对他初始化

1 const int i;

　　这样的定义就是非法的，不符合c++标准。编译器会报错。

　　2.const 常量在文件内有效

　　c++中，如果程序包含多个文件，而每个文件都需要使用某个const对象，c++ 规定需要在声明和定义是都加上‘extern’关键字。

　　

 1 1.c：
 2 
 3 #include <stdio.h>
 4 extern const int i;
 5 
 6 int main()
 7 {
 8     printf("%d\n",i);
 9 }
10 
11 2.c ：
12 
13 extern int i =3;

　　对上边两个文件分别用gcc和g++进行编译，结果gcc发出了一条警告，说i变量已被初始化，却又加上extern。可见c语言并不吃这一套。

 

　　3 .const和 引用

　　一般来说，应用类型必须和所引用的对象类型一致，但是const引用却是例外:

double value = 1.23;
const int &cval = value;//合法

这里有一个转换的过程，其实cval引用绑定在一个临时的变量上。编译器是这么处理的：

1 const int tmp = value;// 隐式转换
2 const int &cval = tmp;

　　4.const和指针

　　关于顶层const，和底层const的区别：

1 int i=3;
2 const int* p = &i;// 不可以通过p指针修改i的值，底层const 
3 int* const p = &i;//p的值不可以修改，顶层const

　　简而言之靠右的是顶层const，靠左的是底层const。

 

　　5.const和编译器优化

　　c++编译器往往会对const对象进行优化，编译器会把出现const对象的地方直接用常量值代替。

 1 #include <iostream>
 2 using namespace std;
 3 
 4 int main()
 5 {
 6     const int i =3;
 7     int* p = const_cast<int*>(&i);
 8     *p=4;
 9     cout << i << endl;
10 }

　　于是第9行 会被编译器 处理为 cout<< 3<< endl; 输出结果也就是3了。

　　但是我们可以使用volatile关键字通知c++编译器，我们的const对象的值是可以发生变化的，于是编译器就会很识趣的不再为你做出替代const对象的优化。

 1 #include <iostream>
 2 using namespace std;
 3 
 4 int main()
 5 {
 6     volatile const int i =3;
 7     int* p = const_cast<int*>(&i);
 8     *p=4;
 9     cout << i << endl;
10 }

　　于是输出结果就像意料的那样是4了。

 

　　6.const和typedef

　　当typedef给一个复合类型取别名时，用const对这个别名进行修饰时，const是对给定类型进行修饰，而不可以理解为简单的替换。　

1 typedef int* pint;
2 int i=3;
3 const pint p1 = &i;
4 p1 = NULL;//非法，p1是常量指针
5 *p1 =4 ;// 合法的，因为i的值不是const的

　　pint是int* 的别名，是一个指向int的指针，因为const修饰的是类型，所以p1是一个 const指针。也就是 int* const p1,如果直接替换的话，就变成了const int* p1,顶层const变成了底层const，显然相去甚远！

转载于:https://www.cnblogs.com/ittinybird/p/4424948.html