程序博客网 > 宜家椅子 知乎

C++ 初始化顺序

来源：互联网 发布：宜家椅子 知乎 编辑：程序博客网 时间：2024/04/30 02:39
1.初始化列表：
       与其他函数不同，构造函数除了有名字，参数列表和函数体之外，还可以有初始化列表，初始化列表以冒号开头，后跟一系列以逗号分隔的初始化字段。
struct foo { 
     string name ; 
     int id ; 
     foo(string s, int i):name(s), id(i){} ; // 初始化列表
};
2.          构造函数的执行可以分成两个阶段，初始化阶段和计算阶段，初始化阶段先于计算阶段。所有类类型（class type）的成员都会在初始化阶段初始化，即使该成员没有出现在构造函数的初始化列表中。

3.何时使用初始化列表：
      c++语言规定，不能在类体中直接指定数据成员的初值，所以对象的初始化工作职能通过调用对象的构造函数来完成。初始化列表在构造函数中扮演了重要角色。
       对于普通的数据成员而言，使用初始化列表和在构造函数体内赋值，效果是一样的。在另外一些情况下，只能使用初始化列表对成员进行初始化，否则会发生编译错误。例如，数据成员是引用、常量、类对象（该类没有提供不带参数的构造函数）等。如下：
[cpp] view plaincopy
  1. /*******Program 1*********/  
  2. #include <iostream>  
  3. using namespace std;  
  4.   
  5. class A{  
  6.      int i;  
  7. public:  
  8.      A(){  
  9.           i = 1;  
  10.      }  
  11.   
  12.      void show(){  
  13.           cout<<i<<endl;  
  14.      }  
  15. };  
  16.   
  17. class B{  
  18.      int i;  
  19. public:  
  20.      B():i(1){}  
  21.      void show(){  
  22.           cout<<i<<endl;  
  23.      }  
  24. };  
  25.   
  26. int main(){  
  27.      A().show();  
  28.      B().show();  
  29. }  
  30. /*******end of Program 1*********/  

输出结果：
1
1
类A的构造函数和类B的构造函数实际上没有任何差别。

[cpp] view plaincopy
  1. /******* Program 2*********/  
  2. #include <iostream>  
  3. using namespace std;  
  4.   
  5. class A{  
  6.      int num;  
  7. public:  
  8.      A(int i){  
  9.           num = i;  
  10.      }  
  11.   
  12.      void show(){  
  13.           cout<<num<<endl;  
  14.      }  
  15. };  
  16.   
  17. class B{  
  18.      int &r;  
  19.      const double PI;  
  20.      A a;  
  21. public:  
  22.      B(int i){}  
  23.      void show(){  
  24.           cout<<r<<endl;  
  25.           cout<<PI<<endl;  
  26.           a.show();  
  27.      }  
  28. };  
  29. int e = 5;  
  30. B::B(int i):r(e),PI(3.1415926),a(i){}  
  31.   
  32. int main(){  
  33.      B(1).show();  
  34. }  
  35. /*******end of Program 2*********/  

输出结果：
5
3.1415926
1
如果在类B的构造函数中，将初始化列表中的任何一个成员的初始化工作移到函数体内，都会导致变异错误:：
[cpp] view plaincopy
  1. B::B(int i){  
  2.      r = e;          // 这是为引用赋值，并不是初始化  
  3.      PI = 3.1415926; // 常量的值不允许改变  
  4.      a = A(i);       // 在类B的构造函数调用之前，会先调用类A的构造函数A()，而此时函数无定义  
  5. }  

4.初始化列表提高程序运行效率：
       有时利用对象之间的赋值来代替初始化，而不是显示使用初始化列表，这样虽然不会发生编译错误，但会造成程序运行效率降低：
[cpp] view plaincopy
  1. /*******Program 3*********/  
  2. #include <iostream>  
  3. using namespace std;  
  4.   
  5. class A{  
  6.      int num;  
  7. public:  
  8.      A(){  
  9.           cout<<"In default constructor"<<end;  
  10.      }  
  11.      A(int i){  
  12.           cout<<"In user-defined constructor"<<end;  
  13.           num = i;  
  14.      }  
  15.      A & operator=(const A& a){  
  16.           cout<<"Using assignment"<<endl;  
  17.           num = a.num;  
  18.           return *this;  
  19.      }  
  20.      void show(){  
  21.            
  22.      }  
  23. };  
  24.   
  25. class B{  
  26.      A a;  
  27. public:  
  28.      B(int i){}  
  29.      void show(){  
  30.           a.show();  
  31.      }  
  32. };  
  33.   
  34. B::B(int i){  
  35.      a = A(i);  
  36. }  
  37.   
  38. int main(){  
  39.      B b(1);  
  40.      b.show();  
  41. }  
  42. /*******end of Program 3*********/  


输出结果：
In default constructor
In user-defined constructor
Using assignment
1
没有显示地在初始化列表中对成员对象a进行初始化，则在进入类B的构造函数体之前，会调用类A的默认构造函数。在类B的构造函数体内进行的是赋值操作，并且要调用类A的构造函数A(int)先生成一个无名对象。这种为成员对象初始化的方式不仅逻辑结构不清晰，而且效率低下。如果将B的构造函数改写成：
B::B(int i):a(i){}
   则程序的输出结果变成:：
In user-defined constructor
1
这样效率明显提高

       表面上看，有很多类的构造函数根本没有使用初始化列表。但实际上，有些内容不管有没有显示写进初始化列表，都是会被“强行”加进去的：
(1)如果该类是某个类的派生类，那么他的直接基类的构造函数一定要出现在初始化列表中。要么是程序员显示地在初始化列表中调用直接基类的构造函数，否则编译器把直接基类的默认构造函数插入到初始化列表中。
(2)如果该类包含其他类的对象作为其数据成员，那么这些对象的初始化工作也一定要在初始化列表中完成。要么是程序员显示地在初始化列表中给出对象的构造形式，否则编译器会在初始化列表中调用这些对象的默认构造函数来完成初始化。

5.成员变量的初始化顺序：
基类的构造函数最先执行，其他的成员按照它们在类中声明的顺序依次被初始化，而不是按照它们在初始化列表出现的顺序初始化。
[cpp] view plaincopy
  1. /*******Program 4*********/  
  2. #include <iostream>  
  3. using namespace std;  
  4.   
  5. class A{  
  6.      int num;  
  7. public:  
  8.      A(int i){  
  9.           cout<<"In A constructor"<<end;  
  10.           num = i;  
  11.      }  
  12. };  
  13.   
  14. class B{  
  15. public:  
  16.      int num;  
  17.      B(int i){  
  18.           num = i;  
  19.           cout<<"In B constructor"<<endl;  
  20.      }  
  21. };  
  22.   
  23. class C{  
  24. protected:  
  25.      int num;  
  26. public:  
  27.      C(int i){  
  28.           num = i;  
  29.           cout<<"In C constructor"<<endl;  
  30.      }  
  31. };  
  32.   
  33. class D:public C{  
  34.      A a;  
  35.      int num;  
  36.      B b;  
  37. public:  
  38.      D(int i):num(i++),b(i++),a(i++),C(i++){}  
  39.      void show(){  
  40.           cout<<"C::num="<<C::num<<endl;  
  41.           cout<<"a.num="<<a.num<<endl;  
  42.           cout<<"num="<<num<<endl;  
  43.           cout<<"b.num="<<b.num<<endl;  
  44.      }  
  45. };  
  46.   
  47. int main(){  
  48.      D d(1);  
  49.      d.show();  
  50. }  
  51. /*******end of Program 4*********/  


输出结果：
In C construtor
In A construtor
In B construtor
C::num=1
a.num=2
num=3
b.num=4

6.     在初始化列表中，无法完成为对象的数组成员进行初始化的工作，原因是C++语言没有提供这样的机制，所以只能在构造函数体内分别为成员数组的每个元素分别赋初值。如果数组元素本身也是对象，那么这种赋值操作会造成较大的运行时开销。问题还不止这些。如果类体中定义一个常量数组，如何进行初始化呢？
       在实际应用中，通常只会在类中定义静态的常量数组，这样就可以完成数组的初始化工作。如果确实想在类中定义一个常量数组，一个变通的做法是定义一个指向常量的指针常量，然后在初始化列表中为它初始化。
[cpp] view plaincopy
  1. /******Program 5*********/  
  2. #include <iostream>  
  3. using namespace std;  
  4. int *CreateArr(int n){  
  5.      int *p;  
  6.      p = new int[n];  
  7.      for (int i=0;i<n;i++)  
  8.      {  
  9.           p[i] = i+1;  
  10.      }  
  11.      return p;  
  12. }  
  13.   
  14. class A{  
  15.      int arrsize;  
  16.      const int* const arr;  
  17. public:  
  18.      A(int n):arr(CreateArr(n)){  
  19.           arrsize=n;  
  20.      }  
  21.      void show(){  
  22.           for (int i=0;i<arrsize;i++)  
  23.           {  
  24.                cout<<arr[i]<<' ';  
  25.           }  
  26.           cout<<endl;  
  27.      }  
  28.       
  29.      ~A(){  
  30.           delete[] arr;  
  31.      }  
  32. };  
  33.   
  34. int main(){  
  35.      A a(3);  
  36.      a.show();  
  37. }  
  38. /*******end of Program 5*********/  


输出结果： 
1 2 3
由于实际上在构造函数中为arr分配了空间，所以应该在类A的析构函数中释放这部分空间
~A(){
          delete[] arr;
     }
这样保证不发生内存泄露。

我原来的博客地址http://licaiqiubzt.blog.163.com/blog/static/2072822482012111093541393/
宜家椅子 知乎 宜家椅子 知乎
原创粉丝点击
热门IT博客
爬虫数据分析爬虫数据分析
教育机构 知乎教育机构 知乎
sql更新语句怎么写
人生遥控器 知乎
淘宝零食模块怎么写
淘宝瑕疵化妆品真假
js防刷新的倒计时代码
关机还原软件
教育信息化数据填报
淘宝直播视频开店教程
淘宝店铺认证在哪里
淘宝差评投诉入口
农村淘宝的盈利模式
monaco.ttf windows
网络大电影合作说明
黑道圣徒2优化
.net程序员面试宝典
电脑音乐录音软件
win10怎么下载软件
js 数组 lastindexof
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 表排名 世界明表 买手表什么牌子好 手表女款 什么手表好看 世界手表 手表都有哪些品牌 longings 手表排行 防水手表 情侣对表 创意手表 瑞士男士手表品牌排行榜 陶瓷手表 品牌钟表 什么牌子的表好 明表百名排行表价格 noob厂表值得买吗 男表 名牌表排行 表排行 手表在哪里买比较好 金色手表 男机械手表 手表女士 女士腕表 男士带什么手表 女士品牌手表 超薄手表 手表淘宝 机械手表品牌排行榜 什么牌子的手表好 男土手表 网上买表哪个网站好 男表品牌 国产手表排名 国产名牌手表 男士表什么牌子好 表的品牌大全 手表专卖店 女机械表

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里