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這樣的方式。