C++双冒号和单冒号的用法区别

一.单冒号（:）

1.用作位域标号
    有些信息在存储时，并不需要占用一个完整的字节， 而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1 两种状态， 用一位二进位即可。为了节省存储空间，并使处理简便，C语言又提供了一种数据结构，称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域，并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。

一、位域的定义和位域变量的说明位域定义与结构定义相仿，其形式为： 
    struct 位域结构名 
    { 位域列表 }; 
其中位域列表的形式为： 类型说明符 位域名：位域长度 
例如： 

[cpp]  view plain  copy

 print ?

1. struct bs   
2. {   
3.   int a:8;   
4.   int b:2;   
5.   int c:6;   
6. };   

位域变量的说明与结构变量说明的方式相同。 可采用先定义后说明，同时定义说明或者直接说明这三种方式。例如： 

[cpp]  view plain  copy

 print ?

1. struct bs   
2. {   
3.   int a:8;   
4.   int b:2;   
5.   int c:6;   
6. }data;   

说明 data为bs变量，共占两个字节。其中位域a占8位，位域b占2位，位域c占6位。对于位域的定义尚有以下几点说明： 
1. 一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如： 

[cpp]  view plain  copy

 print ?

1. struct bs   
2. {   
3.   unsigned a:4   
4.   unsigned :0 /*空域*/   
5.   unsigned b:4 /*从下一单元开始存放*/   
6.   unsigned c:4   
7. }   

在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。 
2. 位域可以无位域名，这时它只用来作填充或调整位置。 无名的位域是不能使用的。例如： 

[cpp]  view plain  copy

 print ?

1. struct k   
2. {   
3.   int a:1   
4.   int :2 /*该2位不能使用*/   
5.   int b:3   
6.   int c:2   
7. };   

3. 取地址操作符&不能应用在位域字段上;

4. 位域字段不能是类的静态成员;

5. 位域字段在内存中的位置是按照从低位向高位的顺序放置的;

6. 当要把某个成员说明成位域时,其类型只能是int,unsigned int与signed int三者之一(说明:int类型通常代表特定机器中整数的自然长度。short类型通常为16位,long类型通常为32位,int类型可以为16位或32位.各编译器可以根据硬件特性自主选择合适的类型长度.见The C Programming Language中文 P32)。

另：C++标准库提供了一个bitset 类模板，它可以辅助操纵位的集合。在可能的情况下应尽可能使用它来取代位域。

从以上分析可以看出，位域在本质上就是一种结构类型， 不过其成员是按二进位分配的。

2.用作条件语句

与?构成条件语句，作用相当于if else，如下；

[cpp]  view plain  copy

 print ?

1. int a,b,c;  
2. a=3;  
3. b=2;  
4. c=a>b?a:b;// 如果a>b成立，则反a赋给c，否则把b赋给c  

条件语句的结构为：
条件表达式?表达式1:表达式2
当条件表达式为true时，表达式的值为表达式1的值，否则为表达式2的值。
几点说明：
1）可以嵌套，但不推荐使用（难懂），下面的表达式你能看懂啥意思不？

[cpp]  view plain  copy

 print ?

1. int max = i>j ? i>k ? i : k : j>k ? j : k;  

脑袋大了吧，呵呵。
2） 具有很低的优先级，这个要注意哦，下面的程序执行结果是啥呢？

[cpp]  view plain  copy

 print ?

1. int i = 3;  
2. int j = 2;  
3. cout << i>j?i:j;// 出错，<span style="font-family: Arial; font-size: 15.5555562973022px; line-height: 26px; color: rgb(0, 147, 0);"><strong><<比>具有更高的优先级</strong></span><span style="font-family: Arial; font-size: 15.5555562973022px; line-height: 26px;">，执行顺序为 ((cout<<i)>j)?i:j,相当于是比较cout<<i与j的大小，然后根据比较结果决定表达式值为i或j，这显然要出错的，cout<<i的值是cout，不能跟整型数j进行比较。</span><br style="font-family: Arial; font-size: 15.5555562973022px; line-height: 26px;" /><span style="font-family: Arial; font-size: 15.5555562973022px; line-height: 26px;">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</span><br style="font-family: Arial; font-size: 15.5555562973022px; line-height: 26px;" /><span style="font-family: Arial; font-size: 15.5555562973022px; line-height: 26px;">cout <<(i>j?i:j);//i>j则输出i，否则输出j，表达式值为true如果cout正确执行，否则为false</span>  

更多的关于优先级的问题就不说了。

3.用作语句标签
通常跟goto配合使用，如：

[cpp]  view plain  copy

 print ?

1. step1: a = f1();  
2.        ....  
3.        goto step1;  

这种作法也不是很推荐，原因在于 它破坏了语句的顺序执行，这样的代价大家应该清楚吧。不过存在即为合理嘛，既然它还存在，肯定还是有它的用处有它的好处的，比如说，多层嵌套的退出（会比break continue直观一点吧），也可以避免重复代码之类之类的
4.用作初始化列表
在构造函数后面紧跟着冒号加初始化列表，各初始化变量之间以逗号(,)隔开。下面举个例子。

[cpp]  view plain  copy

 print ?

1. class myClass  
2. {  
3. public :  
4.   myClass();// 构造函数，无返回类型，可以有参数列表，这里省去  
5.   ~myClass();// 析构函数  
6.   int a;  
7.   const int b;  
8. }  
9. myClass::myClass():a(1),b(1)// 初始化列表  
10. {  
11. }  

5.声明基类
假设我们重新定义一个类，继承自myClass类。定义方式如下：

[cpp]  view plain  copy

 print ?

1. class derivedClass : public myClass  
2. {  
3. // 略去  
4. }  

        这里的冒号起到的就是 声名基类的作用，在基类类名前面可以加 public\private\protected等标签，用于标识继承的类型，也可以省略，省略的话，用 class定义的类默认为private，用struct定义的类默认为public。

与初始化列表一样的，这里也可以声名多个基类，各基类之间用逗号(,)隔开。

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)

::是作用域，说明CAboutDlg是类内部的一个函数

:是初始化，由于CAboutDialog类从CDialog继承过来的，所以需要对其父类进行初始化

原型应该是这样的

class CDialog

{

CDialog(UINT IDD);

}

class CAboutDlg : public CDialg

{

public:

CAboutDlg()

}

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)

这个是CAboutDlg的构造函数，由于CAboutDlg在构造时需要构造CDialog（没有父亲就没有儿子），所以在构造CAboutDlg时需要初始化CDialog类，
由于构造函数CAboutDlg写在类外面，所以需要::来说明作用域是CAboutDlg类，而构造函数后面接初始化则需要用:,如果你的CAboutDlg类中还有成员变量比如 int i之类的，还可以接在后面继续来初始化如：CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD),i(10)
:表示初始化开始，如果多个成员初始化用,隔开。

二．双冒号（::）用法
1.表示 “域操作符”
例：声明了一个类A，类A里声明了一个成员函数void f()，但没有在类的声明里给出f的定义，那么 在类外定义f时， 
就要写成 void A::f() ，表示这个f()函数是类A的成员函数。
2. 直接用在全局函数前，表示是全局函数 
例：在VC里，你可以在调用API 函数里，在API函数名前加：：
3.表示引用成员函数及变量，作用域成员运算符
例：System::Math::Sqrt() 相当于System.Math.Sqrt()
4.命名空间作用域符，即2直接用在全局函数前，表示是全局函数 
在运算符等级中属于最高级的！
using namespace 命名空间名（如，abc）；
表示在以下程序代码中所使用的标示符（如果此标示符在abc中定义）是abc中的，包括类型名（类），变量名，函数名，对象名。。。
using abc::标示符(i)；
只表示在以下代码中使用的标示符i是abc中的。
如果你要使用abc中的多个标示符的话，你就只能用

[cpp]  view plain  copy

 print ?

1. using abc::a;  
2. using abc::b;  
3. using abc::c;  
4. ...  

等一个一个列举出来！
当然用using 语句是比较方便的
但是不安全
（1）using namespace；万一不同的两个命名空间中使用了同名的标示符，系统则不能判断，这个标示符是属于哪个命名空间的；
（2）using abc::；万一你的程序中也用到了一个函数（函数名与abc中的这个函数同名），那么系统也不能判断你使用的是 abc中的那个函数，还是本程序中的那个函数；
最安全的办法（当然也是最繁琐的）
就是，每当你用到一个变量（函数...)时，你都要明确他的来历（即属于哪个命名空间）除非它没有命名空间
例如：

[cpp]  view plain  copy

 print ?

1. #include <iostream>  
2. int main ()  
3. {  
4. std::cout << "hello, world!" << std::endl;  
5. }  

这里就用到了iostream文件中的两个对象（ cout，endl）
因为C++标准库中绝大部分的函数，对象...都放在了命名空间std中
所以
上面的代码就等同于

[cpp]  view plain  copy

 print ?

1. #include <iostream>  
2. using std::cout；  
3. using std::endl;  
4. int main ()  
5. {  
6. cout << "hello, world!" << endl;  
7. }  
8.   
9. #include <iostream>  
10. using namespace std;  
11. int main ()  
12. {  
13. cout << "hello, world!" << endl;  
14. }  

重新举个例子，再加以说明：

[cpp]  view plain  copy

 print ?

1. #include <iostream>  
2. #include <string>  
3. int main ()  
4. {  
5. int a;  
6. std::string b;  
7. std::cin >> a;  
8. std::cin >> b;  
9. std::cout << "hello, world!" << std::endl;  
10. return 0;  
11. }  

1)using std::；

[cpp]  view plain  copy

 print ?

1. #include <iostream>  
2. #include <string>  
3. using std::cin;  
4. using std::endl;  
5. using std::string;  
6. int main ()  
7. {  
8.     int a;  
9.     string b;  
10.     cin >> a;  
11.     cin >> b;  
12.     std::cout << "hello, world!" << endl; //注意cout没用用using  
13.     return 0;  
14. }  

2)using namespace ；

[cpp]  view plain  copy

 print ?

1. #include <iostream>  
2. #include <string>  
3. using namespace std;  
4. int main ()  
5. {  
6.     int a;  
7.     string b;  
8.     cin >> a;  
9.     cin >> b;  
10.     cout << "hello, world!" << endl;  
11.     return 0;  
12. }  

其中cout endl cin string都是std中的！