c++中的點號(.)，冒號（:）和雙冒號（::）運算子

標籤：c++ 冒號運算子   c++雙冒號運算子   冒號與雙冒號   點號.運算子   

1.冒號（:）用法

（1）表示機構內位域的定義（即該變數占幾個bit空間）

typedef struct _XXX{             unsigned char a:4;  //char型的字元a佔4位             unsigned char c;} XXX;

（2）建構函式後面的冒號起分割作用，是類給成員變數賦值的方法，初始化列表，更適用於成員變數的常量const型。

struct _XXX{         _XXX() : y(0xc0) {  }};

（3） public:和private:後面的冒號，表示後面定義的所有成員都是公有或私人的，直到下一個"public:”或"private:”出現為止。"private:"為預設處理。

（4）類名冒號後面的是用來定義類的繼承。

 class 衍生類別名 : 繼承方式  基類名
{
        衍生類別的成員
};
繼承方式：public、private和protected，預設處理是public。

2．雙冒號（::）用法

（1）表示“網域作業符”
        例：聲明了一個類A，類A裡聲明了一個成員函數void f()，但沒有在類的聲明裡給出f的定義，那麼在類外定義f時， 就要寫成void A::f()，表示這個f()函數是類A的成員函數。
（2）直接用在全域函數前，表示是全域函數
        例：在VC裡，你可以在調用API 函數裡，在API函數名前加 ::
（3）表示引用成員函數及變數，範圍成員運算子
        例：System::Math::Sqrt() 相當於System.Math.Sqrt()
——————————————————————————————————————

VC中如下
      ::是C++裡的“範圍分解運算子”。比如聲明了一個類A，類A裡聲明了一個成員函數voidf()，但沒有在類的聲明裡給出f的定義，那麼在類外定義f時，就要寫成voidA::f()，表示這個f()函數是類A的成員函數。
　　:: 一般還有一種用法，就是直接用在全域函數前，表示是全域函數。當類的成員函數跟類外的一個全域函數同名時，考試,大提示在類內定義的時候，打此函數名預設調用的是本身的成員函數；如果要調用同名的全域函數時，就必須打上::以示區別。比如在VC裡，你可以在調用API函數時，在API函數名前加::。

*********************************************************************************************

這篇文章將總結C/C++中的冒號的用法。

1、位域定義
這個在前面關於位結構體的文章裡說得夠多的了，不再重複了。

2、類建構函式(Constructor）的初始化列表
先說下什麼叫建構函式吧（是不是囉嗦了？C++的人應該都知道了吧，還是以防萬一一下）。所謂建構函式，就是與類同名的函數，它與普通函數的區別在於，它沒有傳回型別。
在建構函式後面緊跟著冒號加初始化列表，各初始設定變數之間以逗號(,)隔開。下面舉個例子。

class myClass{    public :               myClass();// 建構函式，無傳回型別，可以有參數列表，這裡省去               ~myClass();// 解構函式               int a;               const int b;}myClass::myClass():a(1),b(1)// 初始化列表{}

上面的例子展示了冒號的這個用法，下面對這個用法進行幾點說明：
1)初始化列表的作用相當於在建構函式內進行相應成員變數的賦值，但兩者是有差別的。
在初始化列表中是對變數進行初始化，而在建構函式內是進行賦值操作。兩都的差別在對於像const類型資料的操作上表現得尤為明顯。我們知道，const類型的變數必須在定義時進行初始化，而不能對const型的變數進行賦值，因此const類型的成員變數只能（而且必須）在初始化列表中進行初始化，即下面的代碼將會出錯：

myClass::myClass（）{     a = 1;// 沒錯，效果相當於在初始化列表中進行初始化     b = 1;// 出錯，const變數不能進行賦值操作；}

2）初始化的順序與成員變數聲名的順序相同。
     先看一下下面的程式：

myClass::myClass():b(1),a(b){}

這樣的執行結果a,b各是多少呢？b=1,a=1?不是，b=1而a是個隨機數。這一點是相當重要的哦，一般在初始化列表中進行初始化時，初始化的順序應與聲明的順序保持一致，防止出現不必要的錯誤。
3）對於繼承的類來說，在初始化列表中也可以進行基類的初始化，初始化的順序是先基類初始化，然後再根據該類自己的變數的聲明順序進行初始化。

3、聲明基類。
假設我們重新定義一個類，繼承自myClass類。定義方式如下：
class derivedClass : public myClass
{
       // 略去
}
這裡的冒號起到的就是聲名基類的作用，在基類類名前面可以加public/private/protected等標籤，用於標識繼承的類型，也可以省略，省略的話，用class定義的類預設為private，用struct定義的類預設為public，至於具體各個標籤有什麼區別這裡就不說了。
與初始化列表一樣的，這裡也可以聲名多個基類，各基類之間用逗號(,)隔開。

4、條件陳述式(? :)
與?構成條件陳述式，作用相當於if else，如下；
int a,b,c;
a=3;
b=2;
c=a>b?a:b;// 如果a>b成立，則反a賦給c，否則把b賦給c
條件陳述式的結構為：
條件運算式?運算式1:運算式2
當條件運算式為true時，運算式的值為運算式1的值，否則為運算式2的值。
幾點說明：
1）?:可以嵌套，但不推薦使用（難懂），下面的運算式你能看懂啥意思不？
int max = i>j ? i>k ? i : k : j>k ? j : k;
腦袋大了吧，呵呵。
2）?:具有很低的優先順序，這個要注意哦，下面的程式執行結果是啥呢？
int i = 3;
int j = 2;
cout << i>j?i:j; // 出錯，<<比>具有更高的優先順序，執行順序為 ((cout<<i)>j)?i:j,相當於是比較cout<<i與j的大小，然後根據比較結果決定運算式值為i或j，這顯然要出錯的，cout<<i的值是cout，不能跟整型數j進行比較。
cout << (i>j)?i:j; //輸出1或0，相當於(cout<<(i>j))作為判決條件，來決定運算式的值為i或j，而cout<<(i>j)，i>j則輸出1否則0，然後再將(cout<<(i>j))作為？：的條件，如果cout正確執行則為1（true），否則為0（false），以此決定運算式值為i或j
cout <<(i>j?i:j);//i>j則輸出i，否則輸出j，運算式值為true如果cout正確執行，否則為false
更多的關於優先順序的問題就不說了。

5、語句標籤
通常跟goto配合使用，如：
step1: a = f1();
....
goto step1;
這種作法也不是很推薦，原因在於它破壞了語句的順序執行，這樣的代價大家應該清楚吧。不過存在即為合理嘛，既然它還存在，肯定還是有它的用處有它的好處的，比如說，多層嵌套的退出（會比break continue直觀一點吧），也可以避免重複代碼之類之類的

6、switch語句中case後。
這個不說了，要是不會的話，我也沒話可說了。

7、彙編指令模板
這個我也不懂，不班門弄斧了，可以參考一下：http://developer.e800.com.cn/articles/2006/43/1144846933898_1.html
改天學習一下。

*********************************************************************************************

1、 
範圍符號::的前面一般是類名稱，後面一般是該類的成員名稱，C++為例避免不同的類有名稱相同的成員而採用範圍的方式進行區分
如：A,B表示兩個類，在A,B中都有成員member。那麼
A::member就表示類A中的成員member

B::member就表示類B中的成員member

2、 

全域範圍符號：當全域變數在局部函數中與其中某個變數重名，那麼就可以用::來區分如：

char zhou; //全域變數void sleep（）｛    char zhou; //局部變數    char(局部變數) = char(局部變數) *char(局部變數) ;    ::char(全域變數) =::char(全域變數) *char(局部變數);｝

3、 

::是C++裡的“範圍分解運算子”。比如聲明了一個類A，類A裡聲明了一個成員函數voidf()，但沒有在類的聲明裡給出f的定義，那麼在類外定義f時，就要寫成voidA::f()，表示這個f()函數是類A的成員函數。例如

class CA {  public:    int ca_var;    int add(int a, int b);    int add(int a);  };   //那麼在實現這個函數時，必須這樣書寫：  int CA::add(int a, int b)  {    return a + b;  }    //另外，雙冒號也常常用於在類變數內部作為當前類執行個體的元素進行表示，比如:  int CA::add(int a)  {    return a + ::ca_var;  }   //表示當前類執行個體中的變數ca_var。

  

C++中點號(.)運算子

首先介紹一下C++中的結構。對於一個結構來說，
struct MyStruct {
         int member_a;
};

如果有個變數MyStruct s，那麼使用其中的成員元素時可以用
s.member_a = 1;

如果採用指標方法訪問，比如MyStruct * ps，那麼同樣的訪問必須用箭頭號：

ps->member_a = 1;

::只用在類成員函數和類成員變數中。比如，聲明一個類：

class CA {          public:          int ca_var;          int add(int a, int b);          int add(int a);};

那麼在實現這個函數時，必須這樣書寫：
int CA::add(int a, int b)
{
     return a + b;
}

另外，雙冒號也常常用於在類變數內部作為當前類執行個體的元素進行表示，比如:

int CA::add(int a)
{
     return a + ::ca_var;
}

表示當前類執行個體中的變數ca_var。

c++中當定義類對象是指標對象時候，就需要用到->指向類中的成員；當定義一般對象時候時就需要用到"."指向類中的成員.......
例如：

class A{    public:           play();}

如果定義如下：

A *p則：p->play()使用; 左邊是結構指標。
A p 則：p.paly()使用; 左邊是結構變數。

c++中的點號(.)，冒號（:）和雙冒號（::）運算子