const关键字的做用

const类型定义：指明变量或对象的值是不能被更新，引入的目的是为了取代预编译指令

××××××常量必须被初始化×××××××××××××××

const的做用

    A 能够定义const常量，如

             const int Max = 100;

             int Array[Max];

    B 便于进行类型检查，如

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

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

    C 能够保护被修饰的东西，防止意外的修改，加强程序的健壮性。

    上面的一个例子，若是在函数体内修改了i,编译器就会报错，如，void f(const int i ){ i=10;  //error }

    D 为函数重载提供一个refernce（这个不是很理解）

      class A

      {

        ...

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

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

        ...

      }

      E 能够节省空间，避免没必要要的内存分配

     例如：

          #define PI 3.14159     //常量宏

          const double Pi = 3.14159  //此时并未将Pi放入ROM中

          ...

         double i = Pi;    //此时为Pi分配内存，之后再也不分配！

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

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

         double J = PI;  //宏替换，又一次分配内存

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

      F 提升效率

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

 

使用const

   (1) 修饰通常常量，常量组，常对象

修饰符const能够用在类型说明符前，也能够用在类型说明符后，例如：

int const x = 2;   或者  const int x = 2;

int const a[5] = {1,2,3,4,5}; 或 const int a[5] = {1,2,3,4,5};

class A;  const A a; 或 A const a;

    (2) 修饰指针

const int *A;  或 int const *A; //const修饰指向的对象，A可变，A指向的对象不可变

int *const A;    //const修饰指针A，A不可变，A指向的对象可变

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

   （3）修饰引用

const double &A;   //该引用所引用的对象不能被更新

    （4）修饰函数的返回值

const修饰符也能够修饰函数的返回值，是返回值不可被改变，格式以下：

const int Fun1();

    (5)修饰类的成员变量

const修饰符也能够修饰类的成员函数，格式以下：

 class ClassName

{

    public:

           int Fun() const;

           ....

};

这样，函数Fun中不能修改类里面的数据。

    （6）在另外一链接文件中引用const常量

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

extern const int j = 10;  //错误，常量不能够被再次赋值

 

放在类内部的变量有什么限制？

放在类内部的变量不能定义的时候赋值，能够在类构造函数初始化列表或外部初始化。

class

{

    private:

        const int c3 = 7;    //error

        static int c4 = 7;    //error

       static const float c5 = 9;   //error

       ....

};

初始化类内部的变量

   1 初始化列表：

    class A

    {

          public:

               A(int i=0):test(i){}

          private:

               const int test;

};

   2 外部初始化

class A

{

   public:

        static const int i;

};

static const int A::i = 3;

 

const 修饰符能够把对象转变为常数对象，什么意思？

   也就是说利用const进行修饰的变量的值在程序的任意位置将不能再次被修改，就如同常数同样使用！

咱们看看以下两个例子

void main(void)

{

 const int a = 10;

 int b = 20;

 

const int *pi;

 pi = &a;

 cout<< *pi << "|" << a <<endl;
 pi = &b;

 cout<< *pi << "|" << b <<endl;

}

上面的代码中最重要的一句是const int *pi

这句从右向左读做：pi是一个指向int类型的，被定义成const的对象的指针

这样的一种声明方式的做用是能够修改pi这个指针所指向的内存地址，却不能修改指向对象的值；

若是在代码后面添加*pi = 10; 这样的赋值操做是不被容许编译的。

 

void main(void)

{

 int a = 10;

 const int * const pi = &a;

cout << *pi << "|" << a <<endl;

}

上面最重要的一句是const int* const pi;

这句从右向左读做：pi是一个指向int类型对象的const 指针；

这样的一种声明方式的做用是你即不能够修改pi所指向的对象的内存地址，也不能利用指针的解引用方式修改对象的值，也就是*pi = 10这样的方式。