定義一個指針的三種寫法都對：1. int * p; 2. int* p; 3. int *p; 習慣不同而已
定義一個函數指針的三種寫法都對：1. int *p(); 2. int * p(); 3. int* p();
1、指針傳遞和引用傳遞
在C語言中，如果要實現在函數內部改變外部變量的值的話，就應該傳遞這個變量的指針。如果要通過指針訪問變量，必須使用指針運算符“*”。這樣在源代碼中就會顯得比較彆扭：
- void function(int *pval)
- {
- *pval=100;
- //pval=100;先不考慮此處類型轉換的錯誤，該代碼只能改變堆棧中臨時指針變量的地址，而不能改變指針指向對象的值
- }
- int main()
- {
- int x=200;
- function(&x);
- return 0;
- }
爲了能透明地使用指針來訪問變量，C++中引入了“引用”的概念
- void function(int &refval)
- {
- refval=100;
- }
- int main()
- {
- int x=200;
- function(x);
- //當然，如下調用也可以。但這樣做就失去引入"引用"的原本意義了
- int &refx=x;
- function(refx);
- return 0;
- }
這樣一來，只要改一下函數聲明，就可以在源代碼的級別上實現指針訪問和一般訪問的一致性。可以把“引用”想象成一個不需要“*”操作符就可以訪問變量的指針。上面的代碼的C語言形式的僞代碼：
- void function(int *refal)
- {
- *refval=100;
- }
- int main()
- {
- int x=200;
- int *refx=&x;
- function(&x);
- function(refx);
- return 0;
- }
總結：
從概念上講。指針從本質上講就是存放變量地址的一個變量，在邏輯上是獨立的，它可以被改變，包括其所指向的地址的改變和其指向的地址中所存放的數據的改變。
而引用是一個別名，它在邏輯上不是獨立的，它的存在具有依附性，所以引用必須在一開始就被初始化，而且其引用的對象在其整個生命週期中是不能被改變的（自始至終只能依附於同一個變量）。
在C++中，指針和引用經常用於函數的參數傳遞，然而，指針傳遞參數和引用傳遞參數是有本質上的不同的：
指針傳遞參數本質上是值傳遞的方式，它所傳遞的是一個地址值。值傳遞過程中，被調函數的形式參數作爲被調函數的局部變量處理，即在棧中開闢了內存空間以存放由主調函數放進來的實參的值，從而成爲了實參的一個副本。值傳遞的特點是被調函數對形式參數的任何操作都是作爲局部變量進行，不會影響主調函數的實參變量的值。
而在引用傳遞過程中，被調函數的形式參數雖然也作爲局部變量在棧中開闢了內存空間，但是這時存放的是由主調函數放進來的實參變量的地址（指針傳遞參數時，指針中存放的也是實參的地址，但是在被調函數內部指針存放的內容可以被改變，即可能改變指向的實參，所以並不安全，而引用則不同，它引用的對象的地址一旦賦予，則不能改變）。被調函數對形參的任何操作都被處理成間接尋址，即通過棧中存放的地址訪問主調函數中的實參變量。正因爲如此，被調函數對形參做的任何操作都影響了主調函數中的實參變量。
引用傳遞和指針傳遞是不同的，雖然它們都是在被調函數棧空間上的一個局部變量，但是任何對於引用參數的處理都會通過一個間接尋址的方式操作到主調函數中的相關變量。而對於指針傳遞的參數，如果改變被調函數中的指針地址，它將影響不到主調函數的相關變量。如果想通過指針參數傳遞來改變主調函數中的相關變量，那就得使用指向指針的指針，或者指針引用。 即指針傳遞只是傳了一個地址copy, 在函數內部改變形參所指向的地址，不能改變原實參指向的地址，僅可以通過修改形參地址的內容，來達到修改實參內容的目的（原C語言中的通過指針來互換值小函數例子），所以如果想通過被調函數來修改原實參的地址或給重新分配一個對象都是不能完成的，只能使用雙指針或指針引用（下面會進行詳解）。
爲了進一步加深大家對指針和引用的區別，下面我從編譯的角度來闡述它們之間的區別：
程序在編譯時分別將指針和引用添加到符號表上，符號表上記錄的是變量名及變量所對應地址。指針變量在符號表上對應的地址值爲指針變量的地址值，而引用在符號表上對應的地址值爲引用對象的地址值。符號表生成後就不會再改，因此指針可以改變其指向的對象（指針變量中的值可以改），而引用對象則不能修改。
關於C++符號表的進一步總結：http://blog.csdn.net/cclive1601/article/details/8101313
最後，總結一下指針和引用的相同點和不同點：
★相同點：
●都是地址的概念；
指針指向一塊內存，它的內容是所指內存的地址；而引用則是某塊內存的別名。
★不同點：
●指針是一個實體，而引用僅是個別名；
●引用只能在定義時被初始化一次，之後不可變；指針可變；引用“從一而終”，指針可以“見異思遷”；
●引用沒有const，指針有const，const的指針不可變；（具體指沒有int& const a這種形式，而const int& a是有 的， 前者指引用本身即別名不可以改變，這是當然的，所以不需要這種形式，後者指引用所指的值不可以改變）
●引用不能爲空，指針可以爲空；
●“sizeof 引用”得到的是所指向的變量(對象)的大小，而“sizeof 指針”得到的是指針本身的大小；
●指針和引用的自增(++)運算意義不一樣；
●引用是類型安全的，而指針不是 (引用比指針多了類型檢查
2、 指針的指針和指針的引用
在下列函數聲明中，爲什麼要同時使用*和&符號？以及什麼場合使用這種聲明方式?
void func1( MYCLASS *&pBuildingElement );
先來看“int **pp”和“int *&rp”區別。前者是一個指向指針的指針；後者是一個指針的引用。如果這樣看不明白的話，變換一下就清楚了：
typedef int * LPINT;
LPINT *pp;
LPINT &rp;
- void function1(int **p)
- {
- **p=100;
- *p=NULL;
- }
- void function2(int *&ref)
- {
- *ref=100;
- ref=NULL;
- }
可見，“引用”僅僅是爲了給重載操作符提供了方便之門，其本質和指針是沒有區別的。所以只要你碰到*&，就應該想到**。也就是說這個函數修改或可能修改調用者的指針，而調用者象普通變量一樣傳遞這個指針，不使用地址操作符&。
3、關於指針的引用的詳解
下面用三個函數onePointerFunc，poiPointerFunc, refPointerFunc舉例詳解，三個函數均想要在函數調用完畢後可以指向新的對象。傳單指針：voidonePointerFunc(MYCLASS *pMyClass)
{
DoSomething(pMyClass);
pMyClass = // 其它對象的指針
}
調用：MYCLASS* p = new MYCLASS; onePointerFunc(p); 調用onePointerFunc後p沒有指向新的對象：
第二條語句在函數過程中只修改了pMyClass的值。並沒有修改調用者的變量p的值。如果p指向某個位於地址0x008a00的對象，當func1返回時，它仍然指向這個特定的對象。
傳雙指針： voidpoiPointerFunc(MYCLASS** pMyClass);
{
*pMyClass = new MYCLASS;
}
調用：MYCLASS* p =new MYCLASS; poiPointerFunc(&p); 調用poiPointerFunc之後，p指向新的對象。
BTW，在COM編程中，到處都會碰到這樣的用法--例如在查詢對象接口的QueryInterface函數中：
interface ISomeInterface {
HRESULT QueryInterface(IID &iid, void** ppvObj);
……
};
LPSOMEINTERFACE p=NULL;
pOb->QueryInterface(IID_SOMEINTERFACE, &p);
此處，p是SOMEINTERFACE類型的指針，所以&p便是指針的指針，在QueryInterface返回的時候，如果調用成功，則變量p包含一個指向新的接口的指針。
傳指針的引用：voidrefPointerFunc(MYCLASS *&pMyClass);
{
pMyClass = new MYCLASS;
……
}
其實，它和前面所講得指針的指針例子是一碼事，只是語法有所不同。傳遞的時候不用傳p的地址&p，而是直接傳p本身：
調用：MYCLASS* p = new MYCLASS; refPointerFunc(p); 調用refPointerFunc之後，p指向新的對象。
MFC在其集合類中用到的*&作爲返回修飾符的例子--CObList，它是一個CObjects指針列表。
class CObList : public CObject {
……
// 獲取/修改指定位置的元素
CObject*& GetAt(POSITION position);
CObject* GetAt(POSITION position) const;
};
這裏有兩個GetAt函數，功能都是獲取給定位置的元素。區別何在呢？ 區別在於一個讓你修改列表中的對象，另一個則不行。所以如果你寫成下面這樣：CObject* pObj = mylist.GetAt(pos); 則pObj是列表中某個對象的指針，
如果接着改變pObj的值： pObj = pSomeOtherObj; 這並改變不了在位置pos處的對象地址，而僅僅是改變了變量pObj.
但是，如果寫成下面這樣： CObject*& rpObj = mylist.GetAt(pos);
現在，rpObj是引用一個列表中的對象的指針，所以當改變rpObj時，也會改變列表中位置pos處的對象地址--換句話說，替代了這個對象。這就是爲什麼CObList會有兩個GetAt函數的緣故。一個可以修改指針的值，另一個則不能。注意我在此說的是指針，不是對象本身。這兩個函數都可以修改對象，但只有*&版本可以替代對象
4、指針和引用的解釋
-
指針-對於一個類型T，T*就是指向T的指針類型，也即一個T*類型的變量能夠保存一個T對象的地址，而類型T是可以加一些限定詞的，如const、volatile等等。見下圖，所示指針的含義：
![]()
-
引用-引用是一個對象的別名，主要用於函數參數和返回值類型，符號X&表示X類型的引用。見下圖，所示引用的含義：
![]()
5、指針和引用的區別
-
首先，引用不可以爲空，但指針可以爲空。前面也說過了引用是對象的別名，引用爲空——對象都不存在，怎麼可能有別名！故定義一個引用的時候，必須初始化。因此如果你有一個變量是用於指向另一個對象，但是它可能爲空，這時你應該使用指針；如果變量總是指向一個對象，i.e.，你的設計不允許變量爲空，這時你應該使用引用。如下圖中，如果定義一個引用變量，不初始化的話連編譯都通不過（編譯時錯誤）：
![]()
而聲明指針是可以不指向任何對象，也正是因爲這個原因，使用指針之前必須做判空操作，而引用就不必。
-
其次，引用不可以改變指向，對一個對象"至死不渝"；但是指針可以改變指向，而指向其它對象。說明：雖然引用不可以改變指向，但是可以改變初始化對象的內容。例如就++操作而言，對引用的操作直接反應到所指向的對象，而不是改變指向；而對指針的操作，會使指針指向下一個對象，而不是改變所指對象的內容。見下面的代碼：
- #include<iostream>
- using namespace std;
- int main(int argc,char** argv)
- {
- int i=10;
- int& ref=i;
- ref++;
- cout<<"i="<<i<<endl;
- cout<<"ref="<<ref<<endl;
- int j=20;
- ref=j;
- ref++;
- cout<<"i="<<i<<endl;
- cout<<"ref="<<ref<<endl;
- cout<<"j="<<j<<endl;
- return 0;
- }
對ref的++操作是直接反應到所指變量之上，對引用變量ref重新賦值"ref=j"（此處要注意ref是可以重新在賦值的，但指向並不會發生變化），並不會改變ref的指向，它仍然指向的是i，而不是j。理所當然，這時對ref進行++操作不會影響到j。而這些換做是指針的話，情況大不相同，請自行實驗。輸出結果如下：
![]()
-
再次，引用的大小是所指向的變量的大小，因爲引用只是一個別名而已；指針是指針本身的大小，4個字節。見下圖所示：
![]()
從上面也可以看出：引用比指針使用起來形式上更漂亮，使用引用指向的內容時可以之間用引用變量名，而不像指針一樣要使用*；定義引用的時候也不用像指針一樣使用&取址。
- 最後，引用比指針更安全。由於不存在空引用，並且引用一旦被初始化爲指向一個對象，它就不能被改變爲另一個對象的引用，因此引用很安全。對於指針來說，它可以隨時指向別的對象，並且可以不被初始化，或爲NULL，所以不安全。const 指針雖然不能改變指向，但仍然存在空指針，並且有可能產生野指針（即多個指針指向一塊內存，free掉一個指針之後，別的指針就成了野指針）。
總而言之，言而總之——它們的這些差別都可以歸結爲"指針指向一塊內存，它的內容是所指內存的地址；而引用則是某塊內存的別名，引用不改變指向。"
6、特別之處const
在這裏我爲什麼要提到const關鍵字呢？因爲const對指針和引用的限定是有差別的，下面聽我一一到來。
- 常量指針VS常量引用
常量指針：指向常量的指針，在指針定義語句的類型前加const，表示指向的對象是常量。
定義指向常量的指針只限制指針的間接訪問操作，而不能規定指針指向的值本身的操作規定性。
常量指針定義"const int* pointer=&a"告訴編譯器，*pointer是常量，不能將*pointer作爲左值進行操作。
常量引用：指向常量的引用，在引用定義語句的類型前加const，表示指向的對象是常量。也跟指針一樣不能利用引用對指向的變量進行重新賦值操作。
- 指針常量VS引用常量
在指針定義語句的指針名前加const，表示指針本身是常量。在定義指針常量時必須初始化！而這是引用天生具來的屬性，不用再引用指針定義語句的引用名前加const。
指針常量定義"int* const pointer=&b"告訴編譯器，pointer是常量，不能作爲左值進行操作，但是允許修改間接訪問值，即*pointer可以修改。
- 常量指針常量VS常量引用常量
常量指針常量：指向常量的指針常量，可以定義一個指向常量的指針常量，它必須在定義時初始化。常量指針常量定義"const int* const pointer=&c"告訴編譯器，pointer和*pointer都是常量，他們都不能作爲左值進行操作。
而就不存在所謂的"常量引用常量"，因爲跟上面講的一樣引用變量就是引用常量。C++不區分變量的const引用和const變量的引用。程序決不能給引用本身重新賦值，使他指向另一個變量，因此引用總是const的。如果對引用應用關鍵字const，起作用就是使其目標稱爲const變量。即沒有：Const double const& a=1；只有const double& a=1；
總結：有一個規則可以很好的區分const是修飾指針，還是修飾指針指向的數據——畫一條垂直穿過指針聲明的星號（*），如果const出現在線的左邊，指針指向的數據爲常量；如果const出現在右邊，指針本身爲常量。而引用本身與天俱來就是常量，即不可以改變指向。
| 一、引用的概念 引用引入了對象的一個同義詞。定義引用的表示方法與定義指針相似，只是用&代替了*。 例如： Point pt1(10,10); Point &pt2=pt1; 定義了pt2爲pt1的引用。通過這樣的定義，pt1和pt2表示同一對象。 需要特別強調的是引用並不產生對象的副本，僅僅是對象的同義詞。因此，當下面的語句執行後： pt1.offset（2，2）； pt1和pt2都具有（12，12）的值。 引用必須在定義時馬上被初始化，因爲它必須是某個東西的同義詞。你不能先定義一個引用後才 初始化它。例如下面語句是非法的： Point &pt3； pt3=pt1； 那麼既然引用只是某個東西的同義詞，它有什麼用途呢？ 下面討論引用的兩個主要用途：作爲函數參數以及從函數中返回左值。 二、引用參數 1、傳遞可變參數 傳統的c中，函數在調用時參數是通過值來傳遞的，這就是說函數的參數不具備返回值的能力。 所以在傳統的c中，如果需要函數的參數具有返回值的能力，往往是通過指針來實現的。比如，實現 兩整數變量值交換的c程序如下： void swapint(int *a,int *b) { int temp; temp=*a; a=*b; *b=temp; } 使用引用機制後，以上程序的c++版本爲： void swapint(int &a,int &b) { int temp; temp=a; a=b; b=temp; } 調用該函數的c++方法爲：swapint（x,y); c++自動把x,y的地址作爲參數傳遞給swapint函數。 2、給函數傳遞大型對象 當大型對象被傳遞給函數時，使用引用參數可使參數傳遞效率得到提高，因爲引用並不產生對象的 副本，也就是參數傳遞時，對象無須複製。下面的例子定義了一個有限整數集合的類： const maxCard=100; Class Set { int elems[maxCard]; // 集和中的元素，maxCard 表示集合中元素個數的最大值。 int card; // 集合中元素的個數。 public: Set () {card=0;} //構造函數 friend Set operator * (Set ,Set ) ; //重載運算符號*，用於計算集合的交集 用對象作爲傳值參數 // friend Set operator * (Set & ,Set & ) 重載運算符號*，用於計算集合的交集 用對象的引用作爲傳值參數 ... } 先考慮集合交集的實現 Set operator *( Set Set1,Set Set2) { Set res; for(int i=0;i<Set1.card;++i) for(int j=0;j>Set2.card;++j) if(Set1.elems[i]==Set2.elems[j]) { res.elems[res.card++]=Set1.elems[i]; break; } return res; } 由於重載運算符不能對指針單獨操作，我們必須把運算數聲明爲 Set 類型而不是 Set * 。 每次使用*做交集運算時，整個集合都被複制，這樣效率很低。我們可以用引用來避免這種情況。 Set operator *( Set &Set1,Set &Set2) { Set res; for(int i=0;i<Set1.card;++i) for(int j=0;j>Set2.card;++j) if(Set1.elems[i]==Set2.elems[j]) { res.elems[res.card++]=Set1.elems[i]; break; } return res; } 三、引用返回值 如果一個函數返回了引用，那麼該函數的調用也可以被賦值。這裏有一函數，它擁有兩個引用參數並返回一個雙精度數的引用： double &max(double &d1,double &d2) { return d1>d2?d1:d2; } 由於max()函數返回一個對雙精度數的引用，那麼我們就可以用max() 來對其中較大的雙精度數加1： max(x,y)+=1.0; |
參考：
http://blog.csdn.net/ztz0223/article/details/1628216 ： 關於指針和引用說明
http://zhidao.baidu.com/question/490201321.html ： 關於指針引用的一個小例子
http://www.cnblogs.com/psunny/archive/2010/01/15/1648783.html : 關於指針的詳細介紹
char是一個字符類型 C++的內置類型，string是一個字符容器，是模版庫裏面的東西 是一個擴展的模版類 string轉換成char * 可以使用c_str（）方法，char *轉換成string 直接賦值就可以了 char*會隱式轉換成string
雙冒號是類名引導，一般出現在一個類的類名後面，用來標識冒號後面的數據是歸屬於哪個類的，如果一個變量或者函數是一個類的靜態成員，可以直接用類名來引導。 如果已經有一個類的對象 需要調用對象中的一個成員或者函數，就需要用點了。概要來說，如果要是涉及域指定的就是用：：，本質上class和struct都是一個域。
OamString result = BeTracingRecordComFun::executeCmd(expectCmd);
size_t pos1 = result.find("Frame");
if( pos1 == std::string::npos) { }
http://www.cnblogs.com/westfly/archive/2011/06/13/2079356.html : std::string 方法列表