const关键字

  在C语言中，我们习惯用#define来定义常量（#define PI 3.14），但是呢，这个常量没办法给它指定类型。学习C++后，它提供了一种更灵活更安全的方式来定义常量，即使用const修饰符来定义（例如：const float PI=3.14;）.总之，不论在c语言还是c++里const还是比较常见的一种修饰符，那么接下来我们就详细谈谈const有哪些作用及使用方法。

一．1.用const定义常量

     (1)定义基本数据类型

       格式：const 类型 常量名=表达式；或 类型 const 常量名=表达式；

       例如：const float PI=3.14;

       说明：定义常量后，值不能改变

     (2)定义常量数组

       格式：const 类型 数组名[元素个数]={初值表}；

          或 类型 const 数组名[元素个数]={初值表}；

       例如：const int a[5]={0,1,2,5,4};

       说明：定义常量数组后，数组元素的值不能改变

    2.与指针一起使用

     (1)const修饰指向常量的指针

       例如：const char* name=“chen”;(表示定义了一个指向常量“chen”的指针变量)

在这里，name可以随意改变值(name=“liu”)，但是这个地址里面保存的值是不能改变的,就比如说，门牌号可以换，但是里面的人还是原来的人，不改变。

总之，const修饰指向常量的指针，地址可改变，值不能变

     (2)const修饰的常指针

       例如：char* const name=“chen”;

这里表示指针name是一个常量，它不能指向另一个字符串，也就是说，地址不可改变，但是里面的值可以更换。

    (3)指向常量的常指针

例如：const char* const name=“chen”;

表示指针的指向（即地址）不能改变，同时所指地址中的内容也不能改变。

二．有关const及引用

下来看几种情况：

(1)const int n=10;

      int &refn=n;        //错误，将“int &”类型的引用绑定到“const int”初始值设定项时，限定符被丢弃。

(2)int m=10;

     const int &refm=m;    //正确

     m=11;               //m改变，refm也跟着改变

     refm=12;            //错误，不能给常量赋值

(3)int &refn=5;        //错误，原因是非常量引用的初始值必须为左值

     const int &refn=5;   //正确 ，常量具有常性，只有常引用可以引用常量

(4)double d1=1.2;

     int &refd1=d1;  //错误，无法用double类型的d1初始化int&类型的引用

(5)double d1=1.2;

     const int &refd1=d1;  //正确,refd1进行了隐式类型的转换，但是从double转换到const int可能会造成数据的丢失.

三.在c++中，const修饰类的数据成员，这里需要注意个问题：

    数据成员被const修饰后称其为常数据成员，构造函数只能通过初始化列表对其进行初始化，而且任何其他函数都不能对该成员赋值。

下面用一组代码加强理解：

[cpp] view plain copy

 

1. #include<iostream>  
2. using namespace std;  
3. class Date  
4. {  
5. public :  
6.     Date(int year,int month,int day):_year(year),_month(month),_day(day)  
7.     {}                 //用初始化列表对常数据成员进行初始化正确  
8.   
9.     /*Date(int year,int month,int day) 
10.     { 
11.         _year=year; 
12.         _month=month; 
13.         _day=day; 
14.     }*/                //非法  
15.     void show()  
16.     {  
17.         cout<<_year<<"-"<<_month<<"-"<<_day<<endl;  
18.     }  
19. private :  
20.     const int _year ;   
21.     const int _month ;   
22.     const int _day ;   
23. };  
24. int main()  
25. {  
26.     Date d(2000,1,1);  
27.     d.show();  
28.     system("pause");  
29.     return 0;  
30. }  

四．const修饰成员函数

在成员函数后面加const，const修饰this指针所指向的对象，也就是保证调用这个const成员函数的对象在函数内不会被改变。

看看以下几种情况：

1. const对象可以调用非const成员函数和const成员函数吗？

答案是：const对象不可以调用非const成员函数，但可以调用const成员函数.

2. 非const对象可以调用非const成员函数和const成员函数吗？

答案是：可以.

3. const成员函数内可以调用其它的const成员函数非const成员函数吗？

答案是：const成员函数内可以调用其它的const成员函数，但不能调用非const成员函数.

4. 非const成员函数内可以调用其它的const成员函数非const成员函数吗？

答案是：可以.

 从上面的几个问题中，我们可以得出const的权限只能缩小，不可放大. 

下面我们通过一组代码继续说明这个问题：

[cpp] view plain copy

 

1. #include<iostream>  
2. using namespace std;  
3. class Date  
4. {  
5. public :  
6.     void Display1 ()  
7.     {  
8.         cout<<"Display ()" <<endl;  
9.         cout<<"year:" <<_year<< endl;  
10.         cout<<"month:" <<_month<< endl;  
11.         cout<<"day:" <<_day<< endl<<endl ;  
12.     }  
13.     void Display2 () const  
14.     {  
15.         cout<<"Display () const" <<endl;  
16.         cout<<"year:" <<_year<< endl;  
17.         cout<<"month:" <<_month<< endl;  
18.         cout<<"day:" <<_day<< endl<<endl;  
19.     }  
20. private :  
21.     int _year ; // 年  
22.     int _month ; // 月  
23.     int _day ; // 日  
24. };  
25. void Test ()  
26. {  
27.     Date d1 ;  
28.     d1.Display1 ();  
29.     d1.Display2();  
30.     const Date d2;  
31.     //d2.Display1();  //编译器报错，因为const对象调用了非const成员函数  
32.     d2.Display2 ();  
33. }  
34. int main()  
35. {  
36.     Test();  
37.     system("pause");  
38.     return 0;  
39. }  

关于const修饰符目前就整理这么些，希望进一步学习后有更好的补充。