const與#define的區別

一、const

（1）爲何須要const成員函數？

        C中經常使用：「 #define 變量名 變量值」定義一個值替代,然而卻有個致命缺點：缺少類型檢測機制，這樣預處理在C++中成爲可能引起錯誤的隱患，因而引入const。

        咱們定義的類的成員函數中，經常有一些成員函數不改變類的數據成員，也就是說，這些函數是"只讀"函數，而有一些函數要修改類數據成員的值。若是把不改變數據成員的函數都加上const關鍵字進行標識，顯然，可提升程序的可讀性。其實，它還能提升程序的可靠性，已定義成const的成員函數，一旦企圖修改數據成員的值，則編譯器按錯誤處理。

（2）const成員函數和const對象

　　實際上，const成員函數還有另一項做用，即常量對象相關。對於內置的數據類型，咱們能夠定義它們的常量，用戶自定義的類也同樣，能夠定義它們的常量對象。例如，定義一個整型常量的方法爲：

　　const int i=1 ；

　　一樣，也能夠定義常量對象，假定有一個類classA，定義該類的常量對象的方法爲：

　　const classA a(2)；

　　這裏，a是類classA的一個const對象，"2"傳給它的構造函數參數。const對象的數據成員在對象壽命期內不能改變。

        可是，如何保證該類的數據成員不被改變呢？

　　爲了確保const對象的數據成員不會被改變，在C++中，const對象只能調用const成員函數。若是一個成員函數實際上沒有對數據成員做任何形式的修改，可是它沒有被const關鍵字限定的，也不能被常量對象調用。下面經過一個例子來講明這個問題：

　　class C
　　{
　　int X;
　　public:
　　int GetX()
　　{
　　return X;
　　}
　　void SetX(int X)
　　{
　　this->X = X;
　　}
　　};
　　void main()
　　{
　　const C constC;
　　cout<
　　}

　　若是咱們編譯上面的程序代碼，編譯器會出現錯誤提示：constC是個常量對象，它只能調用const成員函數。雖然GetX( )函數實際上並無改變數據成員X，因爲沒有const關鍵字限定，因此仍舊不能被constC對象調用。若是咱們將上述代碼中：

　　int GetX()

　　改寫成：

　　int GetX()const

　　再從新編譯，就沒有問題了。

　　const成員函數的使用

　　const成員函數表示該成員函數只能讀類數據成員，而不能修改類成員數據。定義const成員函數時，把const關鍵字放在函數的參數表和函數體之間。有人可能會問：爲何不將const放在函數聲明前呢？由於這樣作意味着函數的返回值是常量，意義徹底不一樣。下面是定義const成員函數的一個實例：

　　class X
　　{
　　int i;
　　public:
　　int f() const;
　　};

　　關鍵字const必須用一樣的方式重複出如今函數實現裏，不然編譯器會把它當作一個不一樣的函數：

　　int X::f() const
　　{
　　return i;
　　}

　　若是f( )試圖用任何方式改變i或調用另外一個非const成員函數，編譯器將給出錯誤信息。任何不修改爲員數據的函數都應該聲明爲const函數，這樣有助於提升程序的可讀性和可靠性。

（3）const使用

a、用於指針的兩種狀況：const是一個左結合的類型修飾符。

　　int const *A; //A可變,*A不可變
　　int *const A; //A不可變,*A可變

b、限定函數的傳遞值參數。

　　void function(const int Var); //傳遞過來的參數在函數內不能夠改變.

c、限定函數返回值型。

　　const int function(); //此時const無心義
　　const myclassname function(); //函數返回自定義類型myclassname.

d、限定函數類型。

　　void function()const; //常成員函數, Const成員函數不能改變對象的成員函數。

　　例如：

　　int Point::GetY()
　　{
　　return yVal;
　　}

　　這個函數被調用時，不改變Point對象，而下面的函數改變Point對象：

　　void Point:: SetPt (int x, int y)
　　{
　　xVal=x;
　　yVal=y;
　　}

　　爲了使成員函數的意義更加清楚，咱們可在不改變對象的成員函數的函數原型中加上const說明：

　class Point
　　{
　　public:
　　int GetX() const;
　　int GetY() const;
　　void SetPt (int, int);
　　void OffsetPt (int, int);
　　private:
　　int xVal, yVal;
　　};

　　const成員函數應該在函數原型說明和函數定義中都增長const限定：

　　int Point::GetY() const
　　{
　　return yVal;
　　}
　　class Set {
　　public:
　　Set (void){ card = 0; }
　　bool Member(const int) const;
　　void AddElem(const int);
　　//...
　　};
　　bool Set::Member (const int elem) const
　　{
　　//...
　　}

　　很是量成員函數不能被常量成員對象調用，由於它可能企圖修改常量的數據成員：

　　const Set s;
　　s.AddElem(10); // 非法: AddElem不是常量成員函數
　　s.Member(10); // 正確

        但構造函數和析構函數對這個規則例外，它們從不定義爲常量成員，但可被常量對象調用（被自動調用）。它們也能給常量的數據成員賦值，除非數據成員自己是常量。

（4）const與指針和引用

a、const與指針

　　先來看看下面的幾種定義：

　　int me；
　　const int * p1=&me；//p1可變，*p1不可變，可是不能用*p1來修改，p1能夠轉向
　　int * const p2=&me；//p2不可變，*p2可變，此時容許*p2來修改其值，可是p2不能轉向。
　　const int *const p3=&me；//p3不可變，*p3也不可變，此時既不能用*p3來修改其值，也不能轉向
　　第一個const的意思是對p1來說它指向的就是const常量，雖然me不是，可是對p1來講就是。

b、指針和引用的的區別很簡單，就是引用更簡潔，更安全。由於引用聲明是必須初始化。 引用更接近const指針，一旦與某個變量關聯，就將一直效忠於他。

c、const指針能夠接受const和非const地址，可是非const指針只能接受非const地址。因此const指針的能力更強一些，因此儘可能多用const指針，這是一種習慣。

二、區別

（1）編譯器處理方式不一樣

　　define宏是在預處理階段展開。

　　const常量是編譯運行階段使用。

（2）類型和安全檢查不一樣

　　define宏常量沒有數據類型，不作任何類型安全檢查，僅僅是展開，在字符替換可能會產生意料不到的錯誤（邊際效應）。

　　const常量有具體的數據類型，在編譯階段會執行類型檢查。

（3）存儲方式不一樣

　　define宏僅僅是展開，有多少地方使用，就展開多少次，不會分配內存。

　　const常量會在內存中分配(能夠是堆中也能夠是棧中)。

（4）const  能夠節省空間，避免沒必要要的內存分配

例如：  

        #define PI 3.14159 //常量宏  
        const doulbe Pi=3.14159; //此時並未將Pi放入ROM中 ......  
        double i=Pi; //此時爲Pi分配內存，之後再也不分配！  
        double I=PI; //編譯期間進行宏替換，分配內存  
        double j=Pi; //沒有內存分配  
        double J=PI; //再進行宏替換，又一次分配內存！

 const定義常量從彙編的角度來看，只是給出了對應的內存地址，而不是象#define同樣給出的是當即數，由於const變量是存放在內存的靜態區域中，因此const定義的常量在程序運行過程當中只有一份拷貝，而 #define定義的常量在內存中有若干個拷貝。 

（5）提升了效率 

編譯器一般不爲普通const常量分配存儲空間，而是將它們保存在符號表中，這使得它成爲一個編譯期間的常量，沒有了存儲與讀內存的操做，使得它的效率也很高。

三、使用規則

（1）const使用規則

在C++ 程序中只使用const常量而不使用宏常量，即const常量徹底取代宏常量。

（2）常量定義規則

規則一：須要對外公開的常量放在頭文件中，不須要對外公開的常量放在定義文件的頭部。爲便於管理，能夠把不一樣模塊的常量集中存放在一個公共的頭文件中。

規則二：若是某一常量與其它常量密切相關，應在定義中包含這種關係，而不該給出一些孤立的值。

例如：

const  float   RADIUS = 100;
const  float   DIAMETER = RADIUS * 2;

（3）類中的常量

        有時咱們但願某些常量只在類中有效。因爲#define定義的宏常量是全局的，不能達到目的，因而想固然地以爲應該用const修飾數據成員來實現。

         const數據成員的確是存在的，但其含義卻不是咱們所指望的。const數據成員只在某個對象生存期內是常量，而對於整個類而言倒是可變的，由於類能夠建立多個對象，不一樣的對象其const數據成員的值能夠不一樣。

        不能在類聲明中初始化const數據成員。如下用法是錯誤的，由於類的對象未被建立時，編譯器不知道SIZE的值是什麼。

  class A
    {…
        const int SIZE = 100; // 錯誤，企圖在類聲明中初始化const數據成員
        int array[SIZE];       // 錯誤，未知的SIZE
    };

        const數據成員的初始化只能在類構造函數的初始化表中進行，例如

class A
    {…
        A(int size);       // 構造函數
        const int SIZE ;  
    };
    A::A(int size) : SIZE(size) // 構造函數的初始化表
    {
      …
    }
    A  a(100);  // 對象 a 的SIZE值爲100
    A  b(200);  // 對象 b 的SIZE值爲200

        怎樣才能創建在整個類中都恆定的常量呢？別期望const數據成員了，應該用類中的枚舉常量來實現。例如：

 class A
    {…
        enum { SIZE1 = 100, SIZE2 = 200}; // 枚舉常量，sizeof（EM） = 4
        int array1[SIZE1];
        int array2[SIZE2];
    };

        枚舉常量不會佔用對象的存儲空間，它們在編譯時被所有求值。枚舉常量的缺點是：它的隱含數據類型是整數，其最大值有限，且不能表示浮點數（如PI=3.14159）。sizeof(A) = 1200;其中枚舉部長空間。