C++中const详解

1.常量：

    通过const关键字将一个变量定义为常量。

    const int bufsize=1024;       如果在程序中试图修改bufsize的值，则会引起一个错误。由于const类型的量一经定义就不能改变它的值，因此在定义时必须初始化。

    const double PI;   //这条语句将产生错误

2.指向const类型对象的指针

    const int *p;   p是一个指向int类型对象的指针，但p本身并不是一个常量。也就是说p可以指向任何一个int类型的对象，但由p所指向的对象不可以通过p来改变值。

3.对象常量

    <类名> const <对象名> 或者 const <类名> <对象名>

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

4. 常指针

    a)<类型> * const <对象> 表示定义一个常量指针，对象本身不能改变，但所指向的值是可以改变的。

    b)const <类型> * <对象> 表示定义一个常量的指针或指针常量，该变量的本身可以改变，但所指向的值是不能改变的。

5.常引用

    const <类型> &<对象>

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

    const double &v；//v是一个引用

    v＝12.3                      //非法，不能更新

6.常成员函数

    使用const关键字进行说明的成员函数，称为常成员函数。只有常成员函数才有资格操作常量或常对象。没使用const说明的成员函数不能用来操作常对象。

常成员函数说明格式如下：

    <返回类型说明符> <函数名> (<参数列表>) const;

    其中，const是加在函数说明后的类型修饰符，它是函数类型的一个组成部分，因此在函数实现部分也要带关键字const。

7.const的用法比较复杂，总结起来又分为以下两种:

(1) 在定义变量时使用:  

   a: const int a=100; 最简单的用法，说明变量a是一个常变量;

   b: int const b=100; 与a功能相同;

   c: const int *a=&b; 指向常数的指针，即指针本身的值是可以

      改变的，但指向的内容是不能改变的;

   d: int const *a=&b; 与c功能相同;

   e: int * const a = &b; 常指针，即指针本身的值是不可改变的，

      但指向的内容是可改变的;

   f: const int * const a = &b;指向常数的常指针,即指针本身与

      指向的内容都是不可改变的;

   g: const int &a=100; 常数引用,即不能改变引用的值;

       总结: 在使用const定义变量时，一定要进行初始化操作,在操作

   符(*,&)左边的修饰的是指向的内容，在右边的是本身。

  

(2) 在函数用使用:

   a: void func(const int a); 做为参数使用，说明函数体内是不能修改该参数的;对不同参数定义时不同的形式，可参见定义变量时使用方式;

   b: const int func(); 做为返回值使用，说明函数的返回值是不能被修改的,在取得返回值时应用const int a = func();对不同参数定义时不同的形式可,参见定义变量时使用方式;

   c: int func() const; 常函数，说明函数是不能修改类中成员的值的，只能用于类的成员函数中;

8. 常量对象的动态创建

      既然编译器可以动态初始化常量，就自然可以动态创建，例如：

  const int* pi=new const int(10);

  这里要注意2点：

  1)const对象必须被初始化！所以(10)是不能够少的。

  2)new返回的指针必须是const类型的。

  那么我们可不可以动态创建一个数组呢？

  答案是否定的，因为new内置类型的数组，不能被初始化。

9. const有什么主要的作用？

(1) 可以定义const常量，具有不可变性。

    例如：

      const int Max=100;

      int Array[Max];   

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

例如：

        void f(const int i) { .........}

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

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

    同宏定义一样，可以做到不变则已，一变都变！如(1)中，如果想修改Max的内容，只需要：const int Max=you want;即可！

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

    还是上面的例子，如果在函数体内修改了i，编译器就会报错；

    例如：

        void f(const int i) { i=10;//error! }

  (5) 为函数重载提供了一个参考。

      class A

      {

      ......

      void f(int i)     {......} file://一个函数

      void f(int i) const {......} file://上一个函数的重载

        ......

      };

  (6) 可以节省空间，避免不必要的内存分配。

      例如：

        #define PI 3.14159       file://常量宏

        const doulbe Pi=3.14159;  file://此时并未将Pi放入ROM中

        ......

        double i=Pi;           file://此时为Pi分配内存，以后不再分配！

        double I=PI;           file://编译期间进行宏替换，分配内存

        double j=Pi;           file://没有内存分配

        double J=PI;           file://再进行宏替换，又一次分配内存！

      const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。

  (7) 提高了效率。

       编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。