C++ const

目录

1、什么是const?

2、为什么引入const？ 

3、cons有什么主要的作用？ 

4、如何使用const？ 

--------------------------------------------------------------------------------------------------------

const关键字实在是神通广大。

在类的外面，它可以用于全局或名字空间常量，以及静态对象（某一文件或程序块范围内的局部对象）。

在类的内部，它可以用于静态和非静态成员。

1、什么是const? 

常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。

2、为什么引入const？ 

const 推出的初始目的，正是为了 取代预编译指令 ，消除它的缺点，同时继承它的优点。 

3、cons有什么主要的作用？ 

（1）可以定义const常量，具有不可变性。

     例如： 
    const int Max=100;

     int Array[Max]; 

（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。

        例如： void fun(const int i) 

                            { .........} 编译器就会知道i是一个常量，不允许修改； 

（3）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。

         同宏定义一样，可以做到不变则已，一变都变！

        如（1）中，如果想修改Max的内容，

        只需要：const int Max=any int;

（4）可以 保护被修饰的东西，防止意外的修改 ，增强程序的健壮性。

         还是上面的例子，如果在函数体内修改了i，编译器就会报错； 例如： 
        void fun(const int i)

             {

                 i=10;//error!

             } 

（5） 为函数重载提供了一个参考。 
class A

 { ...... 
    void f(int i) {......} //一个函数 
    void f(int i) const {......} //上一个函数的重载 ...... 
}; 
（6） 可以节省空间， 避免不必要的内存分配 。 

例如： 
#define PI 3.14159 //常量宏 
const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ...... 

double i=Pi; //此时为Pi分配内存，以后不再分配！ 
double j=Pi; //没有内存分配 

double I=PI; //编译期间进行宏替换，分配内存  
double J=PI; //再进行宏替换，又一次分配内存！ 

const定义常量从汇编的角度来看，只是给出了对应的 内存地址 ，而不是象#define一样给出的是 立即数 ，

所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。 

（7） 提高了效率。

 编译器通常不为普通const常量分配存储空间，而是将它们 保存在符号表 中，

这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。 

4、如何使用const？ 

（1）修饰一般常量 (一般常量是指 简单类型 的常量。)

这种常量在定义时，修饰符const可以用在类型说明符前，也可以用在类型说明符后。 例如： 
int const x=2; 或

 const int x=2; 

（2）修饰常数组( 定义或说明一个常数组可采用如下格式： )
int const a[5]={1, 2, 3, 4, 5}; 
const int a[5]={1, 2, 3, 4, 5}; 

（3）修饰 常对象  常对象是指对象常量，

        定义常对象时，同样要进行初始化，并且该对象不能再被更新，

        定义格式如下： 

        const  类名   对象名；

        类名   const  对象名；
        class A; 

        const A a; 
        A const a; 

（4）修饰常指针 

        const int *A; //const修饰指向的对象，A可变(A可以指向不同的对象)，A指向的对象不可变 （常对象）
        int const *A; //同上

        int *const A; //const修饰指针A，A为常指针， A只能指向一个对象后就不能变了，定义时必须初始化，A指向的对象可变 

        const int *const A;//指针A和A指向的对象都不可变 

（5） 修饰常引用  使用const修饰符也可以说明引用，被说明的引用为常引用， 该引用所引用的对象不能被更新。

            其定义格式如下： 
            const Dog&  泰迪; 

（6）修饰函数的常参数     const修饰符也可以修饰函数的传递参数，

格式如下： 
void Fun(const int Var); 

告诉编译器Var在函数体中的无法改变，从而防止了使用者的一些无意的或错误的修改。

 
（ 7）修饰函数的返回值：  const修饰符也可以修饰函数的返回值， 是返回值不可被改变，

格式如下： 
const int Fun1(); 

const MyClass Fun2(); 

const myclassname function(); //函数返回自定义类型myclassname. 　　

（ 8）修饰类的成员函数：  const修饰符也可以修饰类的成员函数，

格式如下： 
class ClassName 

{ 
public: 
    int Fun() const; ..... 
}； 

这样，在调用函数Fun时就 不能修改类里面的数据

非常量成员函数不能被常量成员对象调用，因为它可能企图修改常量的数据成员： 　

（9）在另一连接文件中引用const常量 

        extern const int i;//正确的引用 

        extern const int j=10;//错误！常量不可以被再次赋值 另外，还要注意，常量必须初始化！ 

        例如： const int i=5; 

3.(4)补充例题

const char *p;与char * const p;的区别

const char *p;他的意思是p指向的目标空间的内容不可变化.
例如

char c='A';

 p=&c;则c的内容不可以变化.

//c='B'; 编译不通过。一些企图改变变量c的值的做法都不行.

p值的变化,这是允许的.然而p仍然是动态的,就是它还可以指向别的空间,被赋予新的地址值,只是被他指向的目标空间的内容不可变化,

如上面的c值始终为'A',不可以更新,而一但p指向别处,则c就更新了.

char * const p; 

 char c='A',m; 

 p=&c;执行后,

c='B'可以执行,

//p=&m则被认为是非法.

const char *p;与char * const p;的区别,他们恰好相反,后者是表明指针p的值不可变,但它指向目标的值可变.
延伸：const char * const & a 的含义 	
  
  

   
   

    
    声明中带有const时,表示为常量.
    
    

    
    对const &a=i
    
    

    
    从右读起 const &a表示a为常量,一开始要对其赋值,这里赋予i,表示a是i的一个
    
    单独
    
    引用.只能引用i
   
   
   
   

    
    在以后的程序中,不能对a本身进行值的修改,即不允许有&a=other  varies 之类的赋值语句.
    
    

    
    

    
    const char * const &a
    
    

    
    是在const &a的基础上声明:const char *a,
   
   
   
   

    
    即对*a(a所指向的内容为常量,不可更改),在以后的程序中,不允许有这样的语句:*a=90;
    
    

    
    

    
    所以整个声明可以理解为:
   
   
   
   

    
    a 是i的一个别名,且永远是i的别名(不会变成其它变量的别名).
   
   
   
   

    
    不能利用a来修改i的值.a只是对i的值的引用.
   
   
  
  

技巧：

一般来说，你可以在头脑里画一条垂直线穿过指针声明中的星号（*）位置，

如果const出现在线的左边，指针指向的数据为常量；

如果const出现在线的右边，指针本身为常量；

如果const在线的两边都出现，二者都是常量。