Good Good code,Day Day up

1. 關于常量引用
正像在C語言中使用指針一樣，C++中通常使用引用
有一個函數
... foo()
并且這個函數返回一個引用...
... & foo()
...., 一個指向位圖(Bitmap)的引用 ...
Bitmap & foo()
.... 并且這個位圖(bitmap)是常量
const Bitmap & foo ()

當然你也可以用指針來做同樣的事情:
const Bitmap * foo()
foo 返回一個指針 ... 指向一個Bitmap ... 并有這個Bitmap是個常量.
Bitmap * const foo()
foo 返回某個東西，這個東西是常量 ... 這個東西又是指針 ... 一個指向Bitmap的指針.
const Bitmap * const foo()
foo 返回某個東西，這個東西是常量 ... 這個東西又是指針 ... 一個指向Bitmap的指針.
....
并且這個Bitmap也是常量.
指針常量與常量指針請參考Blog: http://www.cnblogs.com/JCSU/articles/1019219.html

const總是針對它左邊的東西起作用, 唯一例外的是，如果const是一個最左邊的標識符，那么const將針對它右邊的東西起作用，因些 const int i; 與 int const i; 意思是相同的.
原文請參考: http://www.thescripts.com/forum/thread63796.html

2. 常量函數、常量引用參數、常量引用返回值
例1：bool verifyObjectCorrectness(const myObj &obj); //const reference parameter
例2：void Add(const int &arg) const; //const function
例3：IStack const & GetStack() const { return _stack; } //return const reference

常量引用參數
本例中，一個myObj類型的對象obj通過引用傳入函數verifyObjectCorrectness。為安全起見，使用了const關鍵字來確保函數verifyObjectCorrectness不會改變對象obj所引用的對象的狀態。此外，通過聲明參數常量，函數的使用者可以確保他們的對象不會被改變，也不必擔心在調用函數時帶來副作用。以下代碼試圖對聲明為常量引用的形參進行修改，從而不會通過編譯!

#include <iostream>
using namespace std;

class Test
{
public:
    void f(const int& arg);
private:
    int value; 
};
  
void Test::f(const int& arg) {
    arg=10; //試圖修改arg的值，此行將引起編譯器錯誤 //error C2166: l-value specifies const object
    cout<<"arg="<<arg<<endl; 
    value=20;
}  

void main()
{
  int i=7;
  Test test;
  test.f(i);
  cout<<"i="<<i<<endl; 
}

常量函數
1. 一個函數通過在其后面加關鍵字const，它將被聲明為常量函數
2. 在C++，只有將成員函數聲明為常量函數才有意義。帶有const作后綴的常量成員函數又被稱為視察者(inspector)，沒
    有const作后綴的非常量成員函數被稱為變異者(mutator)
3. 與const有關的錯誤總是在編譯時發現
4. [摘]If the function is not declared const, in can not be applied to a const object, and the compiler will 
         give an error message. A const function can be applied to a non-const object
5. 在C++中，一個對象的所有方法都接收一個指向對象本身的隱含的this指針；常量方法則獲取了一個隱含的常量this指針
    void func_name() const;
    以上說明函數func_name()不會改變*this。當你把this指針看成函數func_name()的一個不可見參數就理解了
    void func_name(T *this) (no const)
    void func_name(const T *this) (const)
6. 常量函數可以被任何對象調用，而非常量函數則只能被非常量對象調用，不能被常量對象調用，如：

class Fred {
 public:
   void inspect() const;   // This member promises NOT to change *this
   void mutate();          // This member function might change *this
 };
 
 void userCode(Fred& changeable, const Fred& unchangeable)
 {
   changeable.inspect();   // OK: doesn't change a changeable object
   changeable.mutate();    // OK: changes a changeable object
 
   unchangeable.inspect(); // OK: doesn't change an unchangeable object
   unchangeable.mutate();  // ERROR: attempt to change unchangeable object
 } 

 

#include <iostream>
using namespace std;

struct A
{
    void f() const { cout<<"const function f is called"<<endl; }
    void f() { cout<<"non-const function f is called"<<endl; }
    void g() { cout<<"non-const function g is called"<<endl; } 
};

void main()
{
    A a;
    const A& ref_a = a;
    a.f(); //calls void f()
    ref_a.f();//calls void f () const
    a.g(); //ok, normal call
    ref_a.g(); //error, const object can not call non-const function
}

7. 在類中允許存在同名的常量函數和非常量函數，編譯器根據調用該函數的對象選擇合適的函數
    當非常量對象調用該函數時，先調用非常量函數；
    當常量對象調用該函數時，只能調用常量函數；
    如果在類中只有常量函數而沒有與其同名的非常量函數，則非常量與常量對象都可調用該常量函數;如：   

#include <iostream>
using namespace std;

struct A
{
    void f() const { cout<<"const function f is called"<<endl; }
    void f() { cout<<"non-const function f is called"<<endl; }
};

void main()
{
    A a;
    const A& ref_a = a;
    a.f(); //calls void f()
    ref_a.f();//calls void f () const
}

輸出結果：
non-const function f is called
const function f is called

#include <iostream>
using namespace std;

struct A{
    void f() const { cout<<"const function f is called"<<endl; }
};

void main()
{
    A a;
    const A& ref_a = a;
    a.f(); //calls void f() const
    ref_a.f();//calls void f () const
}

輸出結果：
const function f is called
const function f is called

8. 以下代碼試圖修改類的數據成員，引起編譯錯誤

#include <iostream>
using namespace std;

class Test
{
public:
    void f(const int& arg) const;
private:
    int value; 
};
  
void Test::f(const int& arg) const{
    //arg=10; 
    cout<<"arg="<<arg<<endl; 
    value=20; //試圖修改Test的數據成員，此行將引起編譯器錯誤 //error C2166: l-value specifies const object
}  

void main()
{
  int i=7;
  Test test;
  test.f(i);
  cout<<"i="<<i<<endl; 
}

9. const關鍵字不能用在構造函數與析構函數中。因為構造函數的目的是初始化域值，因此它必須更改對象，析構函數同理

常量引用返回值
如果你想從常量方法(函數)中通過引用返回this對象的一個成員， 你應該使用常量引用來返回它，即const X&
也就是說你想通過引用返回的東西如果從邏輯上來講是this對象的一部分(與它是否在物理上嵌入在this對象中無關)，那么常量方法需要通過常量引用或者通過值來返回，而不能通過非常量引用返回
原文請參考：http://www.parashift.com/c++-faq-lite/const-correctness.html#faq-18.10

class Person {
public:
    const string& name_good() const; // Right: the caller can't change the name
    string& name_evil() const;       // Wrong: the caller can change the name
    .
};

void myCode(const Person& p) // You're promising not to change the Person object
{
    p.name_evil() = "Igor";  // but you changed it anyway!!
}