c++中冒号（:）、双冒号（::）、初始化列表详解 转载链接 https://blog.csdn.net/shitao827194819/article/details/38335953

转载链接  https://blog.csdn.net/shitao827194819/article/details/38335953

最近学习了C++中一些特殊符号的使用规则，查阅了一些资料和博客，对初始化列表、（：），（：：）的用法进行了梳理，如有理解不周的地方欢迎大家指正

初始化列表

初始化列表其实就是类成员初始化列表(Member Initialization List)的简单说法。

1) 基本概念，初始化列表的形式

[cpp] view plain copy

1. <span style="font-family:KaiTi_GB2312;">#include <iostream>  
2. using namespace std;  
3. class MemberInitializationList  
4. {  
5. private:  
6.          int i;  
7.          int j;  
8. public:  
9.          MemberInitializationList(int val) : j(val), i(j)        // j(val), i(j)就是所谓的成员初始化列表 
   
10. {
11. }
    
12.          inline void printInfo()  
13.          {  
14.                    cout << "i = " << i << ", j = " << j << endl;  
15.          }  
16. };  
17. int main(void)  
18. {  
19.          MemberInitializationList MIL(10);  
20.          MIL.printInfo();        
    
21.          return 0;  
22. }</span> 
    

运行结果：

[cpp] view plain copy

1. <span style="font-family:KaiTi_GB2312;">   
2. i = -858993460   j = 10</span> 
   

如愿以偿被初始化为10，但是i的值为什么是一个奇怪的数字，而不是意想中的10呢？

答案是有些细微的地方需要注意：成员初始化列表的初始化顺序是由类中的成员声明次序决定的，而不是由initialization list中的排列次序决定的。在本例中，先初始化i然后再初始化j。initialization list中的i(j)，表明将j的值赋给i，而此时j还没有被初始化，其值不确定，所以i的值也就不能确定，这就是运行结果中为什么i的值比较奇怪的原因了。

 在任何explicit user code之前，编译器会一一操作initialization list，以适当次序在构造函数内安插初始化操作。

 需要说明的是，据说除了g++编译器会对这种情况给予warning外，其它的编译器都不会给出相关的警告信息。

如果把本例中的构造函数改成：         

[cpp] view plain copy

1. <span style="font-family:KaiTi_GB2312;">MemberInitializationList(int val) : i(val), j(i)  
2.          {  
3.          }</span>  

再运行的结果就正确了：

 i = 10 j = 10  

2) 为什么要使用member initialization list？

根据Stanley Lippman的Inside C++ Object Model，采用member initialization list的方法的效率比较高，即        

[cpp] view plain copy

1. MemberInitializationList(int val) : i(val), j(i) 
   
2. {}
   

的效率要比       

[cpp] view plain copy

1. MemberInitializationList(int val)  
2.        {  
3.                  i = val;  
4.                  j = I;  
5.        }  

高。理由是后者会产生临时性的变量，然后要调用赋值运算符赋给真正的变量，再然后摧毁那个临时性的变量。是否真的是这样呢？我们来做一个试验证明之。验证程序如下：

[cpp] view plain copy

1. #include <iostream>  
2. #include <time.h>  
3. using namespace std;  
4. class MemberInitializationList  
5. {  
6. private:  
7.          int i;  
8.          int j;  
9. public:  
10. //*  
11.          MemberInitializationList(int val) : i(val), j(i)  
12.          {  
13.          }  
14. //*/  
15. /* 
16.          MemberInitializationList(int val) 
17.          { 
18.                    i = val; 
19.                    j = i; 
20.          } 
21. //*/  
22.          inline void printInfo()  
23.          {  
24.                    cout << "i = " << i << ", j = " << j << endl;  
25.          }  
26. };  
27. int main(void)  
28. {  
29.          //cout << CLOCKS_PER_SEC << endl;  
30.          clock_t start = clock();  
31.          for(int i = 0; i < 3000000; i++)  
32.          {  
33.                    MemberInitializationList* pMIL = new MemberInitializationList(i);  
34.                    delete pMIL;  
35.          }  
36.          clock_t finish = clock();  
37.          cout << finish - start << " ms elapsed." << endl;       
    
38.          return 0;  
39. }  

结论：在VC6和VC2005的编译器上，两种方式似乎没有什么区别。或许在别的编译器上有所区别。也就是说，要么微软的编译器对于两种构造函数都使用了临时变量，或者都没有使用临时变量。

3) 调用一个成员函数设定成员变量的初值

[cpp] view plain copy

1. #include <iostream>  
2. #include <time.h>  
3. using namespace std;  
4.    
5. class MemberInitializationList  
6. {  
7. private:  
8.          int i;  
9.          int j;  
10. public:  
11.          MemberInitializationList(int val) : i(setI(val)), j(i)                   // 用成员函数设定成员变量的初始值也是可以的  
12.          {  
13.          }  
14.          inline int setI(int i)  
15.          {  
16.                    return i;  
17.          }  
18.          inline void printInfo()  
19.          {  
20.                    cout << "i = " << i << ", j = " << j << endl;  
21.          }  
22. };  
23.    
24.    
25. int main(void)  
26. {  
27.    
28.          MemberInitializationList MIL(10);  
29.          MIL.printInfo();   
    
30.          return 0;  
31. }  

每个成员在成员初始化表中只能出现一次初始化的顺序不是由名字在初始化表中的顺序决定而是由成员在类中被声明的顺序决定的，但是在初始化表中出现或者在被隐式初始化的成员类对象中的成员总是在构造函数体内成员的赋值之前被初始化， 初始化列表,跟在{}里面的初始化没有什么不同,但在非静态const类型以及引用型成员变量必须在初始化列表里面初始化

在使用C++编程的过程当中，常常需要对类成员进行初始化，常用的2种方法：

第一种方法：

[cpp] view plain copy

1. CMYClass::CSomeClass() { x=0; y=1; }  

第二种方法：

[cpp] view plain copy

1. CSomeClass::CSomeClass() : x(0), y(1) { }  

下面探讨这两种方法的异同以及如何使用这两种方法。

    从技术上说，第二种方法比较好，但是在大多数情况下，两者实际上没有什么区别。第二种语法被称为成员初始化列表，之所以要使用这种语法有两个原因：一个原因是必须这么做，另一个原因是出于效率考虑。

    让我们先看一下第一个原因——必要性。设想你有一个类成员，它本身是一个类或者结构，而且只有一个带一个参数的构造函数。

[cpp] view plain copy

1. <span style="font-family:KaiTi_GB2312;">class CMember { public: CMember(int x) { ... } };</span>  

    因为CMember有一个显式声明的构造函数，编译器不产生一个缺省构造函数（不带参数），所以没有一个整数就无法创建CMember的一个实例。

[cpp] view plain copy

1. <span style="font-family:KaiTi_GB2312;">CMember* pm = new CMember; // 出错!! CMember* pm = new CMember(2); // OK</span>  

    如果CMember是另一个类的成员，你怎样初始化它呢？答案是你必须使用成员初始化列表。

[cpp] view plain copy

1. <span style="font-family:KaiTi_GB2312;">class CMyClass { CMember m_member; public: CMyClass(); }; // 必须使用初始化列表来初始化成员 m_member CMyClass::CMyClass() : m_member(2) { ••• }</span>  

    没有其它办法将参数传递给m_member，如果成员是一个常量对象或者引用也是一样。根据C++的规则，常量对象和引用不能被赋值，它们只能被初始化。

    使用初始化列表的第二个原因是出于效率考虑，当成员类具有一个缺省的构造函数和一个赋值操作符时。MFC的CString提供了一个完美的例子。假定你有一个类CMyClass具有一个CString类型的成员m_str，你想把它初始化为"Hi,how are you."。你有两种选择：

[cpp] view plain copy

1. <span style="font-family:KaiTi_GB2312;">CMyClass::CMyClass() { // 使用赋值操作符 // CString::operator=(LPCTSTR); m_str = _T("Hi,how are you."); }  
2. // 使用初始化列表 // 和构造函数 CString::CString(LPCTSTR) CMyClass::CMyClass() : m_str(_T("Hi,how are you.")) { }</span>  

    在它们之间有什么不同吗？是的。编译器总是确保所有成员对象在构造函数体执行之前被初始化，因此在第一个例子中编译的代码将调用CString::Cstring来初始化m_str，这在控制到达赋值语句前完成。在第二个例子中编译器产生一个对CString:: CString(LPCTSTR)的调用并将"Hi,how are you."传递给这个函数。结果是在第一个例子中调用了两个CString函数（构造函数和赋值操作符），而在第二个例子中只调用了一个函数。

    在CString的例子里这是无所谓的，因为缺省构造函数是内联的，CString只是在需要时为字符串分配内存（即，当你实际赋值时）。但是，一般而言，重复的函数调用是浪费资源的，尤其是当构造函数和赋值操作符分配内存的时候。在一些大的类里面，你可能拥有一个构造函数和一个赋值操作符都要调用同一个负责分配大量内存空间的Init函数。在这种情况下，你必须使用初始化列表，以避免不要的分配两次内存。

    在内建类型如ints或者longs或者其它没有构造函数的类型下，在初始化列表和在构造函数体内赋值这两种方法没有性能上的差别。不管用那一种方法，都只会有一次赋值发生。有些程序员说你应该总是用初始化列表以保持良好习惯，但我从没有发现根据需要在这两种方法之间转换有什么困难。在编程风格上，我倾向于在主体中使用赋值，因为有更多的空间用来格式化和添加注释，你可以写出这样的语句：

[cpp] view plain copy

1. x=y=z=0;  

或者

[cpp] view plain copy

1. memset(this,0,sizeof(this));  

注意第二个片断绝对是非面向对象的。

    当我考虑初始化列表的问题时，有一个奇怪的特性我应该警告你，它是关于C++初始化类成员的，它们是按照声明的顺序初始化的，而不是按照出现在初始化列表中的顺序。

[cpp] view plain copy

1. <span style="font-size:12px;">class CMyClass { CMyClass(int x, int y); int m_x; int m_y; }; CMyClass::CMyClass(int i) : m_y(i), m_x(m_y) { }</span>  

    你可能以为上面的代码将会首先做m_y=i，然后做m_x=m_y，最后它们有相同的值。但是编译器先初始化m_x，然后是m_y,，因为它们是按这样的顺序声明的。结果是m_x将有一个不可预测的值。这个例子是故意这样设计来说明这一点的，然而这种bug会很自然地出现。有两种方法避免它，一个是总是按照你希望它们被初始化的顺序来声明成员，第二个是，如果你决定使用初始化列表，总是按照它们声明的顺序罗列这些成员。这将有助于消除混淆。

冒号（:）用法

（1）表示机构内位域的定义（即该变量占几个bit空间）

[cpp] view plain copy

1. <span style="font-family:KaiTi_GB2312;">typedef struct _XXX{  
2. unsigned char a:4;  
3. unsigned char c;  
4. } ; XXX</span>  

（2）构造函数后面的冒号起分割作用，是类给成员变量赋值的方法，初始化列表，更适用于成员变量的常量const型。

[cpp] view plain copy

1. <span style="font-family:KaiTi_GB2312;">struct _XXX{  
2. _XXX() : y(0xc0) {}  
3. };</span>  

（3） public:和private:后面的冒号，表示后面定义的所有成员都是公有或私有的，直到下一个"public:”或"private:”出现为止。"private:"为默认处理。
（4）类名冒号后面的是用来定义类的继承。

[cpp] view plain copy

1. <span style="font-family:KaiTi_GB2312;">class 派生类名 : 继承方式 基类名  
2. {  
3. 派生类的成员  
4. };</span>  

继承方式：public、private和protected，默认处理是public。

下面重点讲一下构造函数后的（：）

构造函数后加冒号是初始化表达式：
有四种情况下应该使用初始化表达式来初始化成员：
1：初始化const成员
2：初始化引用成员
3：当调用基类的构造函数，而它拥有一组参数时

4：当调用成员类的构造函数，而它拥有一组参数时。

在程序中定义变量并初始化的机制中,有两种形式,一个是我们传统的初始化的形式,即赋值运算符赋值,还有一种是括号赋值,如:

[cpp] view plain copy

1. <span style="font-family:KaiTi_GB2312;">　int a=10;   
2. 　  char b='r';//赋值运算符赋值   
3. 　  int a(10);/   
4. 　  char b('r');//括号赋值 </span>  

以上定义并初始化的形式是正确的,可以通过编译,但括号赋值只能在变量定义并初始化中,不能用在变量定义后再赋值，

冒号初始化是给数据成员分配内存空间时就进行初始化,就是说分配一个数据成员只要冒号后有此数据成员的赋值表达式(此表达式必须是括号赋值表达式),那么分配了内存空间后在进入函数体之前给数据成员赋值，就是说初始化这个数据成员此时函数体还未执行。 对于在函数中初始化,是在所有的数据成员被分配内存空间后才进行的。这样是有好处的,有的数据成员需要在构造函数调入之后函数体执行之前就进行初始化如引用数据成员,常量数据成员和对象数据成员

[cpp] view plain copy

1. <span style="font-family:KaiTi_GB2312;color:#330033;">class student  
2.  　　{public :  
3.  　　　 student ()  
4.  　　　 protected:  
5.  　　　 const int a;  
6.  　　　 int &b;  
7.  　　}  
8.  　 student ::student (int i,int j)  
9.  　{  
10.  　　　 a=i;  
11.  　　　 b=j;  
12.  　 } </span>  

在Student类中有两个数据成员,一个是常量数据成员,一个是引用数据成员,并且在构造函数中初始化了这两个数据成员，但是这并不能通过编译，因为常量初始化时必须赋值，它的值是不能再改变的,与常量一样引用初始化也需要赋值，定义了引用后，它就和引用的目标维系在了一起,也是不能再被赋值的。所以C  ++":"后初始化的机制,使引用和常量数据成员变为可能的，Student类的构造函数应为:  student ::student(int i,int j):a(i),b(j){}

常见的三种情况

1、对含有对象成员的对象进行初始化，例如，
    类line有两个私有对象成员startpoint、endpoint,line的构造函数写成：
    line（int sx,int sy,int ex,int ey）：startpoint（sx,sy），endpoint（ex,ey）{……}
    初始化时按照类定义中对象成员的顺序分别调用各自对象的构造函数，再执行自己的构造函数
    2、对于不含对象成员的对象，初始化时也可以套用上面的格式，例如，
    类rectangle有两个数据成员length、width,其构造函数写成：
    rectangle（）：length（1），width（2）{}
    rectangle（int x,int y）：length（x），width（y）{}
    3、对父类进行初始化，例如，
    CDlgCalcDlg的父类是MFC类CDialog,其构造函数写为：
    CDlgCalcDlg（CWnd* pParent ）： CDialog（CDlgCalcDlg::IDD, pParent）
    其中IDD是一个枚举元素，标志对话框模板的ID
    使用初始化成员列表对对象进行初始化，有时是必须的，有时是出于提高效率的考虑

双冒号（::）用法

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函数名前加::