面向物件是C++的重要特性.
但是c++在c的基礎上新增加的幾點優化也是很耀眼的
就const直接可以取代c中的#define
以下幾點很重要,學不好後果也也很嚴重

const
1. 限定符宣告變數只能被讀
  const int i=5;
  int j=0;
  ...
  i=j;  //非法，導致編譯錯誤
  j=i;  //合法
2. 必須初始化
  const int i=5;    //合法
  const int j;      //非法，導致編譯錯誤
3. 在另一連線檔案中引用const常量
  extern const int i;    //合法
  extern const int j=10;  //非法，常量不可以被再次賦值
4. 便於進行型別檢查
  用const方法可以使編譯器對處理內容有更多瞭解。
  #define I=10
  const long &i=10;  /*dapingguo提醒：由於編譯器的優化，使
      得在const long i=10; 時i不被分配記憶體，而是已10直接代入
      以後的引用中，以致在以後的程式碼中沒有錯誤，為達到說教效
      果，特別地用&i明確地給出了i的記憶體分配。不過一旦你關閉所
      有優化措施，即使const long i=10;也會引起後面的編譯錯誤。*/
  char h=I;      //沒有錯
  char h=i;      //編譯警告，可能由於數的截短帶來錯誤賦值。
5. 可以避免不必要的記憶體分配
  #define STRING "abcdefghijklmn\n"
  const char string[]="abcdefghijklm\n";
  ...
  printf(STRING);  //為STRING分配了第一次記憶體
  printf(string);  //為string一次分配了記憶體，以後不再分配
  ...
  printf(STRING);  //為STRING分配了第二次記憶體
  printf(string);
  ...
  由於const定義常量從彙編的角度來看，只是給出了對應的記憶體地址，
  而不是象#define一樣給出的是立即數，所以，const定義的常量在
  程式執行過程中只有一份拷貝，而#define定義的常量在記憶體中有
  若干個拷貝。
6. 可以通過函式對常量進行初始化
  int value();
  const int i=value();
  dapingguo說：假定對ROM編寫程式時，由於目的碼的不可改寫，
  本語句將會無效，不過可以變通一下：
  const int &i=value();
  只要令i的地址處於ROM之外，即可實現：i通過函式初始化，而其
  值有不會被修改。
7. 是不是const的常量值一定不可以被修改呢？
  觀察以下一段程式碼：
  const int i=0;
  int *p=(int*)&i;
  p=100;
  通過強制型別轉換，將地址賦給變數，再作修改即可以改變const常量值。

8. 請分清數值常量和指標常量，以下宣告頗為玩味：
  int ii=0;
  const int i=0;            //i是常量，i的值不會被修改
  const int *p1i=&i;        //指標p1i所指內容是常量，可以不初始化
  int  * const p2i=ⅈ    //指標p2i是常量，所指內容可修改
  const int * const p3i=&i; //指標p3i是常量，所指內容也是常量
  p1i=ⅈ                  //合法
  *p2i=100;                //合法
關於C++中的const關鍵字的用法非常靈活，而使用const將大大改善程式的健壯性，參考了康建東兄的const使用詳解一文，對其中進行了一些補充，寫下了本文。


1.      const常量，如const int max = 100; 
優點：const常量有資料型別，而巨集常量沒有資料型別。編譯器可以對前者進行型別安全檢查，而對後者只進行字元替換，沒有型別安全檢查，並且在字元替換時可能會產生意料不到的錯誤（邊際效應）

2.      const 修飾類的資料成員。如：
class A

{

    const int size;

    …

}

const 資料成員只在某個物件生存期內是常量，而對於整個類而言卻是可變的。因為類可以建立多個物件，不同的物件其const資料成員的值可以不同。所以不能在類 宣告中初始化const資料成員，因為類的物件未被建立時，編譯器不知道const 資料成員的值是什麼。如

class A

{

const int size = 100;    //錯誤

int array[size];        //錯誤，未知的size

}

const資料成員的初始化只能在類的建構函式的初始化表中進行。要想建立在整個類中都恆定的常量，應該用類中的列舉常量來實現。如

class A

{…

enum {size1=100, size2 = 200 };

int array1[size1];

int array2[size2];

}

列舉常量不會佔用物件的儲存空間，他們在編譯時被全部求值。但是列舉常量的隱含資料型別是整數，其最大值有限，且不能表示浮點數。

3.      const修飾指標的情況，見下式：

int b = 500;
const int* a = &          [1]
int const *a = &          [2]
int* const a = &          [3]
const int* const a = &    [4]
如 果你能區分出上述四種情況，那麼，恭喜你，你已經邁出了可喜的一步。不知道，也沒關係，我們可以參考《Effective c++》Item21上的做法，如果const位於星號的左側，則const就是用來修飾指標所指向的變數，即指標指向為常量；如果const位於星號的 右側，const就是修飾指標本身，即指標本身是常量。

因此，[1]和[2]的情況相同，都是指標所指向的內容為常量（const放在變數宣告符的位置無 關），這種情況下不允許對內容進行更改操作，如不能*a = 3 ；[3]為指標本身是常量，而指標所指向的內容不是常量，這種情況下不能對指標本身進行更改操作，如a++是錯誤的；[4]為指標本身和指向的內容均為常 量。

4.    const的初始化
先看一下const變數初始化的情況
1) 非指標const常量初始化的情況：A b;
const A a = b;
2) 指標const常量初始化的情況：

A* d = new A();
const A* c = d;
或者：const A* c = new A();
3）引用const常量初始化的情況：
A f;
const A& e = f;      // 這樣作e只能訪問宣告為const的函式，而不能訪問一           

般的成員函式；
    [思考1]： 以下的這種賦值方法正確嗎？
    const A* c=new A();
    A* e = c;
    [思考2]： 以下的這種賦值方法正確嗎？
    A* const c = new A();
    A* b = c;

5.    另外const 的一些強大的功能在於它在函式宣告中的應用。在一個函式宣告中，const 可以修飾函式的返回值，或某個引數；對於成員函式，還可以修飾是整個函式。有如下幾種情況，以下會逐漸的說明用法：A& operator=(const A& a);
void fun0(const A* a );
void fun1( ) const; // fun1( ) 為類成員函式
const A fun2( );

1） 修飾引數的const，如 void fun0(const A* a ); void fun1(const A& a);
調 用函式的時候，用相應的變數初始化const常量，則在函式體中，按照const所修飾的部分進行常量化，如形參為const A* a，則不能對傳遞進來的指標的內容進行改變，保護了原指標所指向的內容；如形參為const A& a，則不能對傳遞進來的引用物件進行改變，保護了原物件的屬性。
[注意]：引數const通常用於引數為指標或引用的情況，且只能修飾輸入引數;若輸入引數採用“值傳遞”方式，由於函式將自動產生臨時變數用於複製該引數，該引數本就不需要保護，所以不用const修飾。

[總結]對於非內部資料型別的輸入引數，因該將“值傳遞”的方式改為“const引用傳遞”，目的是為了提高效率。例如，將void Func(A a)改為void Func(const A &a)

      對於內部資料型別的輸入引數，不要將“值傳遞”的方式改為“const引用傳遞”。否則既達不到提高效率的目的，又降低了函式的可理解性。例如void Func(int x)不應該改為void Func(const int &x)

2）  修飾返回值的const，如const A fun2( ); const A* fun3( );
這樣聲明瞭返回值後，const按照"修飾原則"進行修飾，起到相應的保護作用。const Rational operator*(const Rational& lhs, const Rational& rhs)
{
return Rational(lhs.numerator() * rhs.numerator(),
lhs.denominator() * rhs.denominator());
}
返回值用const修飾可以防止允許這樣的操作發生:Rational a,b;
Radional c;
(a*b) = c;
一般用const修飾返回值為物件本身（非引用和指標）的情況多用於二目操作符過載函式併產生新物件的時候。
[總結]

1.    一般情況下，函式的返回值為某個物件時，如果將其宣告為const時，多用於操作符的過載。通常，不建議用const修飾函式的返回值型別為某個物件或對 某個物件引用的情況。原因如下：如果返回值為某個物件為const（const A test = A 例項）或某個物件的引用為const（const A& test = A例項） ，則返回值具有const屬性，則返回例項只能訪問類A中的公有（保護）資料成員和const成員函式，並且不允許對其進行賦值操作，這在一般情況下很少 用到。

2.      如果給採用“指標傳遞”方式的函式返回值加const修飾，那麼函式返回值（即指標）的內容不能被修改，該返回值只能被賦給加const 修飾的同類型指標。如：

const char * GetString(void);

如下語句將出現編譯錯誤：

char *str=GetString();

正確的用法是：

const char *str=GetString();

3.    函式返回值採用“引用傳遞”的場合不多，這種方式一般只出現在類的賻值函式中，目的是為了實現鏈式表達。如：

class A

{…

A &operate = (const A &other);  //負值函式

}
A a,b,c;              //a,b,c為A的物件

…

a=b=c;            //正常

(a=b)=c;          //不正常，但是合法

若負值函式的返回值加const修飾，那麼該返回值的內容不允許修改，上例中a=b=c依然正確。(a=b)=c就不正確了。
[思考3]： 這樣定義賦值操作符過載函式可以嗎？
const A& operator=(const A& a);

6.    類成員函式中const的使用
一般放在函式體後，形如：void fun() const;
任何不會修改資料成員的函式都因該宣告為const型別。如果在編寫const成員函式時，不慎修改了資料成員，或者呼叫了其他非const成員函式，編譯器將報錯，這大大提高了程式的健壯性。如：

class Stack

{

public:

      void Push(int elem);

      int Pop(void);

      int GetCount(void) const;  //const 成員函式

private:

      int m_num;

      int m_data[100];

};

int Stack::GetCount(void) const

{

  ++m_num;              //編譯錯誤，企圖修改資料成員m_num

  Pop();                    //編譯錯誤，企圖呼叫非const函式

  Return m_num;

}

7.      使用const的一些建議
1 要大膽的使用const，這將給你帶來無盡的益處，但前提是你必須搞清楚原委；
2 要避免最一般的賦值操作錯誤，如將const變數賦值，具體可見思考題；
3 在引數中使用const應該使用引用或指標，而不是一般的物件例項，原因同上；
4 const在成員函式中的三種用法（引數、返回值、函式）要很好的使用；
5 不要輕易的將函式的返回值型別定為const;
6除了過載操作符外一般不要將返回值型別定為對某個物件的const引用;
[思考題答案]
1 這種方法不正確，因為宣告指標的目的是為了對其指向的內容進行改變，而宣告的指標e指向的是一個常量，所以不正確；
2 這種方法正確，因為宣告指標所指向的內容可變；
3 這種做法不正確；
在const A::operator=(const A& a)中，引數列表中的const的用法正確，而當這樣連續賦值的時侯，問題就出現了：
A a,b,c:
(a=b)=c;
因為a.operator=(b)的返回值是對a的const引用，不能再將c賦值給const常量。

 

 

1.1.1. 定義普通常量
使用#define來定義常量也是常用方法，但const也可以用來定義常量，在[Effective C++]中建議使用const代替#define來定義常量，因為const定義的常量具有型別資訊，而巨集沒有，所以使用const定義的常量在進行賦值操作時編譯器會進行更嚴格的型別檢查，是型別安全的。

const double PI = 3.1414926;

const int POOL_SIZE = 20;

定義常量有三種方法：巨集、const、enum，其中巨集應該儘量避免，而const與enum也各有優缺點，最大的區別就是enum只能用於定義整數，而不能定義浮點數；而對於定義邏輯關係較近的一組整數時比較適合使用enum，也可以考慮使用類代替enum(參見[??])。

常量必須在定義時進行初始化，之後便不能再賦值。說它不能被賦值並不是說常量的值是絕對不會改變的，只是說不能直接賦值，但可以通過指標及強制型別轉換、const_cast是可以改變常量的值的。

#include

using namespace std;

int main( void )

{

const int ci = 5;

const int* cpci = &ci;

int *pci = (int*)&ci;

cout<<"cpci = "<

return 0;

}

輸出結果：

cpci = 002DFAC8, pci = 002DFAC8

ci=5, *cpci=1, *pci=1

ci=5, *cpci=2, *pci=2

ci != *cpci

之所以使用ci直接輸出變數的值時顯示其值始終沒有改變，但通過指標間接顯示出來的值是改變了，而且輸出結果的最後一行很奇怪，ci的值與*cpci的值居然不相等，只因為編譯器在編譯時進行了優化，將程式碼中的ci直接替換成了5，與巨集替換是相同的效果，而指標的值則是實際記憶體中的值。

所以，千萬不要試圖使用指標強行改變const變數的值，否則程式可能表現出錯誤的行為，而且查詢起來這種錯誤非常困難。在gcc 4.3.4和visual C++ 2010中均預設打開了對常量的優化選項，目前還沒找到關閉該優化的命令列選項，一定不要自作聰明去改const變數的值。

1.1.2. 修飾指標
把const與指標放到一起，很多人便會想到一個繞口令“指標常量與常量指標。“指標常量”即一個指標變數，該變數不能被賦值，而指標指向的記憶體單元的內容是可以改變的；“常量指標”即一個指向常量的指標，指標變數本身可以賦值，而指標指向的記憶體單元的內容是不可以被重新賦值的。

char a = 'A', b = 'B';

const char* ptoc = &a; // 常量指標

*ptoc = 'C'; // 改變指標指向記憶體單元的內容，不可以

ptoc = &b; // 改變指標的值，可以

char* const cp = &a; // 指標常量

cp = &b; // 改變指標的值，不可以

*cp = 'D'; // 改變指標指向記憶體單元的內容，可以

const char* const cptoc = &a; // 指向常量的指標常量

*cptoc = 'E'; // 不可以

cptoc = &b; // 不可以

const是修飾型別還是修飾指標，要看const的位置，放在*前就是修飾資料型別，放到*後就是修飾指標，const char和char const是一樣的。

建議：在不打算修改資料內容的時候都將指標定義成常量指標，不打算指標本身被修改的場合都定義成指標常量。儘可能地多用const，用錯了沒關係，編譯器會提示你的，只要能夠編譯通過，就不會因為用錯const而導致程式邏輯錯誤，應該說const負作用極小。

1.1.3. 修飾類成員常量
當使用const修飾類成員變數時便定義了常資料成員，它的使用與使用類外定義的常量本質上並沒有什麼區別，在這裡只想指出一點：有網友提到const資料成員只能被const修飾的函式使用這是沒有根據的，是錯誤的。

1.1.4. 修飾類成員函式
const修飾成員函式語法：

class Socket

{

public:

typedef unsigned short socket_port_t;

socket_port_t LocalPort( void ) const

{

++readCount;

return _port;

}

private:

socket_port_t _port;

mutable int _readCount;

};

使用const修飾的成員函式不能修改類的成員變數，如成員_port，而且只能呼叫成員類物件const函式，但有個例外，就是mutable修飾的成員變數可以在const修飾的成員函式中被修改，如_readCount。

另外，const只能修飾非靜態函式。

建議：將所有不改變物件狀態的函式都使用const修飾符標識，以提高程式的可讀性。其實，標頭檔案就是最好的類介面的說明文件，越多的提供資訊就能使程式的可讀性越好，越利於維護。看到成員函式的const修飾符，讀者便立即明白該函式不會改變程式的狀態，這也有利於當程式狀態出現異常時的問題定位。

1.1.5. 修飾類物件、物件引用或物件指標（常量指標）
當const修飾自定義的類物件時，與修飾C++內建型別的變數的思想是一致的，但稍有不同，除了不能被賦值外，還不能呼叫沒有使用const修飾的非靜態成員函式。當const修飾類物件引用、指標時限制是一樣的，因為引用本身與直接使用該變數實質上沒有區別，而使用指標只是將.操作符改為了->本質上還是一樣的

const std::string hello = “Hello from Noock Tian;

std::cout<

hello = "Hi"; // 不可以賦值

hello.push_back("!"); // 不可以

1.1.6. 修飾函式引數
const修飾函式的例子是很常見了，表示函式的引數在函式體內不會被意外修改，一般用於修飾輸入引數，例如標準庫中的字串連線函式。str1是輸出引數，其內容會被修改，而str2為輸入引數，其內容不會修改。

char* strcat(char* str1, const char* str2);

實際上在說到const用法一開始就提到，const只是一種宣告，但並不能保證，例如strcat函式雖然聲明瞭str2為const char*型，但並不能保證內部絕對不會修改str2的內容。但const從語言本身提供了一種編寫自描述性程式碼的方法，只要使用函式與實現函式的雙方都達成一致的約定，按照契約程式設計，我們就可以認為const修飾的型別在函式體內不會被修改，這與const修飾類成員函式一樣，可以提高軟體的可讀性。

1.1.7. 修飾函式返回值
const可以用於修飾任何型別，只要返回值型別不是void，const就可以用來修飾返回值的型別。但實際上const用於修飾非引用的返回值型別是沒有意義的，因為返回值一般都會被賦值給另一個變數，此時用於傳遞返回值的物件已經被銷燬，修飾返回值型別的const的作用也就終結了。

當返回值是引用型別時，如果該引用的值不希望被修改是可以宣告為常引用的，例如：

class Socket

{

public:

const string& IP( void ) const{ return _ip; }

private:

string _ip;

};

Socket sock;

string& ip = sock.IP(); // 不可以

const string& ip2 = sock.IP(); // 可以

string ip3 = sock.IP(); // Socket::_ip被複制，可以

此處，為了減少構造臨時變數，將IP函式返回值定義為引用型別以提高程式執行效率，但為了保護內部狀態不會被客戶端程式碼意外，返回值使用const修飾為常引用。但是，如果對於軟體安全性較高的場合，最好不要定義為引用，因為惡意的客戶端程式碼是有可能修改Socket::_ip的值的。

在C++中賦值運算子反預設返回值都是引用，但筆者認為定義為常引用更為合適，例如：

int main( void )

{

int a = 1,b = 2,c = 3,d = 4;

((a=b)=c)=d;

cout<<”a=”<

return 0;

}

輸出結果：

a=4, b=2, c=3, d=4

顯然，在實際工程中誰也不會寫出這樣的程式碼，這段程式碼卻是合法的，無疑這給程式設計師多了一種出錯的可能，如果把賦值運算子的返回值定義為常引用，則會減少程式設計師出錯的機會，例如[??]:

class Object

{

public:

const Object& operator=(const Object& a) { return *this; }

};

int main( void )

{

Object a, b, c, d;

a = b = c = d; // 可以

((a=b)=c)=d; // 不可以

return 0;

}

在gcc 編譯時則會出現錯誤提示：

error: passing ‘const Object’ as ‘this’ argument of ‘const Object& Object::operator=(const Object&)’ discards qualifiers.
當然，不同的編譯器可能錯誤提示不同。

=========================================

傻貨SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS

=======================================================================

const T、const T*、T *const、const T&、const T*& 的區別

原文地址: http://blog.csdn.net/luoweifu/article/details/45600415

這裡的T指的是一種資料型別，可以是int、long、doule等基本資料型別，也可以是自己型別的型別class。單獨的一個const你肯定知道指的是一個常量，但const與其他型別聯合起來的眾多變化，你是不是就糊塗了？下面我們一一來解析。

const T

定義一個常量，宣告的同時必須進行初始化。一旦宣告，這個值將不能被改變。

1. int i = 5;
2. const int constInt = 10; //正確
3. const int constInt2 = i; //正確
4. constInt = 20; //錯誤，常量值不可被改變
5. const int constInt3; //錯誤，未被初

const T*

指向常量的指標，不能用於改變其所指向的物件的值。

1. const int i = 5;
2. const int i2 = 10;
3. const int* pInt = &i; //正確，指向一個const int物件，即i的地址
4. //*pInt = 10; //錯誤，不能改變其所指缶的物件
5. pInt = &i2; //正確，可以改變pInt指標本身的值,此時pInt指向的是i2的地址
6. const int* p2 = new int(8); //正確，指向一個new出來的物件的地址
7. delete p2; //正確
8. //int* pInt = &i; //錯誤，i是const int型別，型別不匹配，不能將const int * 初始化為int *
9. int nValue = 15;
10. const int * pConstInt = &nValue; //正確，可以把int *賦給const int *，但是pConstInt不能改變其所指向物件的值，即nValue
11. *pConstInt = 40; //錯誤，不能改變其所指向物件的值

const int* 與int* const的區別

指標本身就是一種物件，把指標定義為常量就是常量指標，也就是int* const的型別，也可以寫成int *const，宣告時必須初始化。

1. int nValue = 10;
2. int* const p = &nValue;
3. int *const p2 = &nValue;
4. const int* 指標指向的物件不可以改變，但指標本身的值可以改變；int* const 指標本身的值不可改變，但其指向的物件可以改變。
5. int nValue1 = 10;
6. int nValue2 = 20;
7. int* const constPoint = &nValue1;
8. //constPoint = & nValue2; //錯誤，不能改變constPoint本身的值
9. *constPoint = 40; //正確，可以改變constPoint所指向的物件，此時nValue1 = 40
10.  
11.  
12. const int nConstValue1 = 5;
13. const int nConstValue2 = 15;
14. const int* pPoint = &nConstValue1;
15. //*pPoint = 55; //錯誤，不能改變pPoint所指向物件的值
16. pPoint = &nConstValue2; //正確，可以改變pPoint指標本身的值，此時pPoint邦定的是nConstValue2物件，即pPoint為nConstValue2的地址

---

const int* const 是一個指向常量物件的常量指標，即不可以改變指標本身的值，也不可以改變指標指向的物件。

1. const int nConstValue1 = 5;
2. const int nConstValue2 = 15;
3. const int* const pPoint = &nConstValue1;
4. //*pPoint = 55; //錯誤，不能改變pPoint所指向物件的值
5. //pPoint = &nConstValue2; //錯誤，不能改變pPoint本身的值

---

const T&

對常量(const)的引用，又稱為常量引用，常量引用不能修改其邦定的物件。

1. int i = 5;
2. const int constInt = 10;
3. const int& rConstInt = constInt; //正確，引用及邦定的值都是常量
4. rConstInt = 5; //錯誤，不能改變引用所指向的物件

允許為一個常量引用邦定一個非常量物件、字面值，甚至是表示式；引用的型別與引用所指向的型別必須一致。

1. int i = 5;
2. int& rInt = i; //正確，int的引用
3. const int constInt = 10;
4. const int& rConstInt = constInt; //正確，引用及邦定的值都是常量
5. const int& rConstInt2 = rInt; //正確，用rInt邦定的物件進行賦值
6. rInt = 30; //這時，rConstInt2、rInt、i的值都為30
7. //rConstInt2 = 30; //錯誤，rConstInt2是常量引用，rConstInt2本身不能改變所指向的物件
8.  
9.  
10. int i2 = 15;
11. const int& rConstInt3 = i2; //正確，用非常量的物件為其賦值
12. const int& rConstInt4 = i + i2; //正確，用表示式為其賦值,值為45
13. i = 20; //此時i=20, rInt = 20, rConstInt4 = 45,說明rConstInt4邦定的是i + i2的臨時變數
14. const int& rConstInt5 = 50; //正解，用一個常量值為其賦值

---

const T*&與T *const&

指向常量物件的指標的引用，這可以分兩步來理解：1.const T*是指向常量的指標；2.const T*&指向常量的指標的引用。

1. const int nConstValue = 1; //常量物件
2. const int nConstValue2 = 2; //常量物件
3. const int* pConstValue = &nConstValue; //指向常量物件的指標
4. const int* pConstValue2 = &nConstValue2; //指向常量物件的指標
5. const int*& rpConstValue = pConstValue; //指向常量物件的指標的引用
6. //*rpConstValue = 10; //錯誤，rpConstValue指向的是常量物件，常量物件的值不可改變
7. rpConstValue = pConstValue2; //正確，此時pConstValue的值等於pConstValue2
8. //指向常量物件的指標本身是物件，引用可以改變邦定物件的值
9.  
10. int nValue = 5;
11. int nValue2 = 10;
12. int *const constPoint = &nValue; //常量指標
13. int *const constPoint2 = &nValue2; //常量指標
14. int *const &rpConstPoint = constPoint; //對常量指標的引用,邦定constPoint
15. //rpConstPoint = constPoint2; //錯誤，constPoint是常量指標，指標本身的值不可改變
16. *rpConstPoint = 20; //正確，指標指向的物件可以改變

---

在函式中的應用

我們直接從需求出來，假設有這樣一個數據結構：

1. typedef struct __Data
2. {
3. int value;
4. public:
5. __Data()
6. :value(0){}
7. }Data;

1.希望傳入一個物件，又不想讓函式體修改這個物件。

方式<1>

1. void Dealwith(const Data& data)
2. {
3. cout << data.value << endl;
4. //data.value = 5; //錯誤，data是常量引用，不能改變其邦定的物件
5. }

這種方式還有一個好處是隻有在呼叫函式的時候會邦定物件，傳遞的是物件的引用，而不是物件，減少函式呼叫時物件賦值的花銷。

方式<2>

1. void Dealwith(const Data* pData)
2. {
3. cout << pData->value << endl;
4. //pData->value = 5; //錯誤，pData是指向常量物件的指標，不能改變其指向的物件
5. }

這種方式與void Dealwith(const Data& data)的功能相同

方式<3>

1. Data g_data(20);
2. void Dealwith(const Data*& pData)
3. {
4. cout << pData->value << endl;
5. //pData->value = 5; //錯誤，pData邦定的是指向常量物件的指標，常量物件的指標不能改變其指向的物件
6. pData = &g_data; //正確，pData是[指向常量物件的指標]的引用，引用可改變其邦定的物件
7. }

呼叫如下：

1. Data d(10);
2. const Data* pData = &d;
3. Dealwith(pData);
4. cout << pData->value << endl; //此時pData->value為20，d.value還是10

這種方式函式未改變傳入的物件的值，但可以返回另外一個物件的指標。注意返回的指標必須指向全域性的物件，如果返回函式內定義的物件，退出函式作用域後，其指標將無效，這是非常危險的；如果Dealwith是成員函式，也可以返回指向成員的指標。

2.在類中的使用，返回一個類的成員，但不希望呼叫方修改這個成員。

方式<1>

1. class MyData
2. {
3. public :
4. MyData(std::string name, Data data)
5. {
6. m_name = name;
7. m_data = data;
8. }
9.  
10. const Data* GetData()
11. {
12. return &m_data;
13. }
14.  
15.  
16. private:
17. std::string m_name;
18. Data m_data;
19. };

呼叫如下：

1. MyData mydata("", Data(100));
2. const Data* pData = mydata.GetData();
3. cout << pData->value << endl; //pData->value = 100
4. //pData->value = 50; //錯誤，pData是指向常量物件的指向，不能改變其指向物件的值

方式<2>

有人可能會問GetData也可以寫成這樣：

1. const Data& GetData()
2. {
3. return m_data;
4. }

這樣的話，呼叫方常常容易寫成這樣：

1. MyData mydata("", Data(100));
2. Data data = mydata.GetData(); //這會有個賦值的過程，會把mydata.m_data賦給data
3. cout << data.value << endl; //data.value = 100
4. data.value = 50; //正確，data.value=50，但mydata.m_data.value還是100

這樣呼叫時會有一個結果賦值的過程，如果Data是一個複雜的類，會有較大的開銷，其效果與下面這種方式是一樣的：

1. Data GetData()
2. {
3. return m_data;
4. }

當然，如果呼叫方這樣使用是正確的：

1. const Data& GetData()
2. {
3. return m_data;
4. }

1. MyData mydata("", Data(100));
2. const Data& data = mydata.GetData(); //這會有個賦值的過程，會把mydata.m_data賦給data
3. cout << data.value << endl; //data.value = 100
4. //data.value = 50; //錯誤，data是一個對常量的引用，不能改變其邦定的物件

這對呼叫方的技術能力要求比較高，如果你是設計方，一定要儘量使介面簡單易用。

方式<3>

如果你要傳入一個Data進行一些處理，處理完後返回類的成員m_data，可如下實現：

1. void DoSomething(const Data*& pData)
2. {
3. if (pData != NULL)
4. {
5. // doto: 這裡實現你要處理的功能
6. }
7. pData = &m_data;
8. }