全球彩票平台_全球彩票注册平台|官网下载地址

热门关键词: 全球彩票平台,全球彩票注册平台,全球彩官网下载地址

全球彩票注册平台开始化列表,构造函数之伊始

(笔记):构造函数之开始化列表,构造函数开始化

一、为了更加好的验证最先化列表,首先由二个张冠李戴的代码引进:

全球彩票注册平台 1

 1 #include<iostream>
 2  
 3 #include"string.h"
 4 using namespace std;
 5 
 6 class Student
 7 {
 8     private:
 9     int Num,Chinese,Maths,English;
10     float Total;
11     char Name[20];
12     public:
13         Student(){}//默认构造函数 
14          Student(char name[20],int num,int chinese,int maths,int english);
15 
16 };
17 Student::Student(char name[20],int num,int chinese,int maths,int english){
18     int n;
19     for(n=0;n<strlen(name);n  )
20         Name[n]=name[n];
21     Num=num;
22     Chinese=chinese;
23     English=english;
24     Maths=maths;
25     Total=maths chinese english;
26 }
27  
28 int main()
29 {
30     int i,j;
31     int num,chinese,maths,english;
32     char name[20];
33     Student std[5];//因为有了默认构造函数所以此时编译可以通过
34         
35     for(i=0;i<5;i  )
36     {
37         cin>>name[20]>>num>>chinese>>maths>>english;
38         std[i](name[20],num,chinese,maths,english);
39         for(j=0;j<20;j  )
40         name[j]='\0';    
41         
42     }
43 }

View Code

上边代码在编写翻译的时候出现二个谬误提醒:
[Error] no match for call to '(Student) (char&, int&, int&, int&, int&)'
该错误定位到上边那行std[i](name[20],num,chinese,maths,english);该段代码错误的因由是误认为先定义五个Student 的数组,之后调用构造函数来进展赋值,实际上,构造函数是在Student std[5];那句定义的时候就调用暗许构造函数起首化了 (即使读者不领会构造函数的实践进度请参见小编的上篇笔记)。全部构造函数(能够是暗许构造也许非平凡构造)都以在概念的时候就调用,定义以往的调用就不叫最早化了,而是赋值。写那么些错误代码的人,分明是不曾知道构造函数是怎么施行的,
她的目标是通过轮回依次调用构造函数来实行起初化。当然大家能够遵照她的主见来进展"正确"的编纂代码,将上边的失进行出修改为std[i].Student(name[20],num,chinese,maths,english);

那样看起来才疑似对象自己来调用构造函数举办早先化。缺憾的是,那样也是无计可施编写翻译的,现身上面包车型客车错误新闻:
[Error] invalid use of 'Student::Student'

并发如此的荒谬是因为,C 本人就要求在概念的时候系统活动调用构造函数,而指标是不能够调用构造函数的。

消除方案:

1、可以在概念的时候一向开端化,为了方便的求证难点,大家把下面的Student std[5];那句代码中改为1个数组成分,for循环去掉,
就成为下边包车型地铁代码了(这段代码仅仅c 11支撑):

全球彩票注册平台 2

 1 #include<iostream>
 2  
 3 #include"string.h"
 4 using namespace std;
 5 
 6 class Student
 7 {
 8     private:
 9     int Num,Chinese,Maths,English;
10     float Total;
11     char Name[20];
12     public:
13         Student(){}//默认构造函数 
14          Student(char name[20],int num,int chinese,int maths,int english);
15 
16 };
17 Student::Student(char name[20],int num,int chinese,int maths,int english){
18     int n;
19     for(n=0;n<strlen(name);n  )
20         Name[n]=name[n];
21     Num=num;
22     Chinese=chinese;
23     English=english;
24     Maths=maths;
25     Total=maths chinese english;
26 }
27  
28 int main()
29 {
30     int i,j;
31     int num,chinese,maths,english;
32     char name[20];
33     Student std[1] = { { name,num,chinese,maths,english} };
34         
35 
36 }

View Code

2、还是可以够定义一多级指针,然后再每一回构造的时候调用new来构造类对象。
如:

1 Student *std[5];
2 for(i=0;i<5;i  )
3 {
4 cin>>name[20]>>num>>chinese>>maths>>english;
5 std[i]=new Student(name,num,chinese,maths,english);
6 */ 

为了越来越好的看看new对象的时候,构造函数是怎么施行的,轻巧的改观一下方面包车型客车代码如下:

全球彩票注册平台 3

 1 #include<iostream>
 2  
 3 #include"string.h"
 4 using namespace std;
 5 
 6 class Student
 7 {
 8     private:
 9     int Num,Chinese,Maths,English ;
10     float Total;
11     public:
12         Student(){}//默认构造函数 
13          Student( int num );
14 
15 };
16 Student::Student(int num ){
17     
18     cout<<"第" << num <<"个构造函数" <<endl; 
19     Num = num;
20     cout<<"Num = "<<num<<endl;
21 }
22  
23 int main()
24 {
25     int i;
26     int num,chinese,maths,english;
27 
28     Student *std[5];
29     for(i=0;i<5;i  )
30     {
31         std[i]=new Student( i );//每申请一块内存就自动调用构造函数     
32     }
33 }

View Code

结果如图所示:

全球彩票注册平台 4

由此地点的一无所长实例,大家开采有一点点代码出现错误的原由就算从未明了好构造函数的实施进程。不晓得你有未有开采
笔者在上边包车型大巴代码中连连在构造函数的内部,对Student类的分子变量进行赋值,这里严苛来讲并非最早化(有关起初化概念请参考上篇笔记),
那是叁个赋值计算的进度,在概念二个变量的时候自动的施行构造函数里面包车型大巴赋值代码。

二、面引出开始化列表。

形如上面包车型地铁代码:在构造函数的背后有个 : 符号,前边紧跟着对成员变量的起始化。

 1 class Student
 2 {
 3     private:
 4     int m_num,m_maths ;
 5     public:
 6         Student(){}//默认构造函数 
 7         Student(int num,int maths  ):m_num(num),m_maths(maths)
 8         {
 9             
10             cout<<"进入计算阶段" <<endl; 
11             cout<<"m_num = "<<num<<endl;
12         } 
13 
14 };

为了越来越好的问询早先化列表,首先大家要明了,构造函数的实施能够分为三个等第,开头化阶段和计量阶段,起先化阶段先于总计阶段。而初叶化阶段便是对应着早先化列表这有个别,而计量阶段正是构造函数的函数体部分。初叶化阶段先于总计阶段实践,如上面程序:

 1 #include<iostream>
 2  
 3 #include"string.h"
 4 using namespace std;
 5 
 6 class Student
 7 {
 8     private:
 9     int m_num,m_maths ;
10     public:
11         Student(){}//默认构造函数 
12          Student(int num,int maths );
13 };
14 Student::Student(int num,int maths  ):m_num(num),m_maths(maths)
15 {
16     cout<<"进入计算阶段前m_num = "<<m_num <<endl; 
17     this->m_num = 2;
18     cout<<"进入计算阶段后查看m_um = "<<m_num<<endl;
19 }
20  
21 int main()
22 {
23     
24     Student A(1,2); 
25 }

检查测试结果图如下:

全球彩票注册平台 5

从图中得以看出,在步向计算阶段前大家看出了m_num的值变为了1,在图谋阶段后m_全球彩票注册平台,num变为了2,所以说伊始化阶段先于总括阶段完结。

下边说贝拉米(Bellamy)(Dumex)下开头化列表的长处:它比在构造函数总计阶段(函数体内)进行赋值功用越来越高(仅仅针对类类型的变量)。上边有两段代码和呼应的结果图片,代码2是在代码1的功底上改换了Student2的构造函数为开首化列表格局。

代码1:

全球彩票注册平台 6

 1 #include<iostream>
 2  
 3 using namespace std;
 4 
 5 class Student1 {
 6     public:
 7         int a;
 8             
 9          Student1()                         // 无参构造函数
10         { 
11             cout << "默认构造函数Student1" << endl ;
12         }
13     
14         Student1(const Student1& t1) // 拷贝构造函数
15         {
16             cout << "拷贝构造函数Student1" << endl ;
17             this->a = t1.a ;
18         }
19     
20         Student1& operator = (const Student1& t1) // 赋值运算符
21         {
22             cout << "赋值函数Student1" << endl ;
23             this->a = t1.a ;
24             return *this;
25         }
26  };
27 class Student2
28 {
29     public:
30      
31     Student1 test ;
32     Student2(Student1 &t1){            //图1结果 
33         test  = t1 ;
34     }
35 };
36 int main()
37 {
38     
39     Student1 A;
40     Student2 B(A);
41 
42 }

View Code

代码2:

全球彩票注册平台 7

 1 #include<iostream>
 2  
 3 using namespace std;
 4 
 5 class Student1 {
 6     public:
 7         int a;
 8             
 9          Student1()                         // 无参构造函数
10         { 
11             cout << "默认构造函数Student1" << endl ;
12         }
13     
14         Student1(const Student1& t1) // 拷贝构造函数
15         {
16             cout << "拷贝构造函数Student1" << endl ;
17             this->a = t1.a ;
18         }
19     
20         Student1& operator = (const Student1& t1) // 赋值运算符
21         {
22             cout << "赋值函数Student1" << endl ;
23             this->a = t1.a ;
24             return *this;
25         }
26  };
27 class Student2
28 {
29     public:
30      
31     Student1 test ;
32      Student2(Student1 &t1):test(t1){}
33 };
34 int main()
35 {
36     
37     Student1 A;
38     Student2 B(A);
39 
40 } 

View Code

代码1图:

全球彩票注册平台 8

代码2图:

全球彩票注册平台 9

从图中得以见到第一段代码的推断结果调用了2次构造函数和1次赋值函数,而代码2结出,调用了1次构造函数和1次拷贝函数。
当代码量非常多的时候会发觉,代码2比代码1效用更加高。

 

一、为了更加好的认证早先化列表,首先由八个荒唐的代码引进: 1 #includeiostream 2 3 #i...

一、为了更加好的表达开端化列表,首先由一个错误的代码引进:

一、为了越来越好的申明起初化列表,首先由二个荒谬的代码引进:

=

称得上最初化列表

与另外函数不一样,构造函数除了盛名字,参数列表和函数体之外,还足以有初阶化列表,初叶化列表以冒号初叶,后跟一文山会海以逗号分隔的开端化字段。在C 中,struct和class的有一无二不同是暗中认可的访问性分裂,而这里我们不思索访谈性的题目,所以下边包车型地铁代码都是struct来演示。

struct foo
{
    string name ;
    int id ;
    foo(string s, int i):name(s), id(i){} ; // 初始化列表
};

全球彩票注册平台 10全球彩票注册平台 11

全球彩票注册平台 12全球彩票注册平台 13

称得上初步化列表

与其余函数不相同,构造函数除了著名字,参数列表和函数体之外,还足以有开首化列表,开端化列表以冒号发轫,后跟一两种以逗号分隔的开头化字段。在C 中,struct和class的天下无双差异是暗许的访问性分化,而这里大家不思虑访问性的标题,所以上面包车型客车代码都以struct来演示。

struct foo
{
    string name ;
    int id ;
    foo(string s, int i):name(s), id(i){} ; // 初始化列表
};

构造函数的四个实行阶段

构造函数的施行能够分成多少个等级,伊始化阶段和计算阶段,最初化阶段先于总结阶段。

 1 #include<iostream>
 2  
 3 #include"string.h"
 4 using namespace std;
 5 
 6 class Student
 7 {
 8     private:
 9     int Num,Chinese,Maths,English;
10     float Total;
11     char Name[20];
12     public:
13         Student(){}//默认构造函数 
14          Student(char name[20],int num,int chinese,int maths,int english);
15 
16 };
17 Student::Student(char name[20],int num,int chinese,int maths,int english){
18     int n;
19     for(n=0;n<strlen(name);n  )
20         Name[n]=name[n];
21     Num=num;
22     Chinese=chinese;
23     English=english;
24     Maths=maths;
25     Total=maths chinese english;
26 }
27  
28 int main()
29 {
30     int i,j;
31     int num,chinese,maths,english;
32     char name[20];
33     Student std[5];//因为有了默认构造函数所以此时编译可以通过
34         
35     for(i=0;i<5;i  )
36     {
37         cin>>name[20]>>num>>chinese>>maths>>english;
38         std[i](name[20],num,chinese,maths,english);
39         for(j=0;j<20;j  )
40         name[j]='\0';    
41         
42     }
43 }
 1 #include<iostream>
 2  
 3 #include"string.h"
 4 using namespace std;
 5 
 6 class Student
 7 {
 8     private:
 9     int Num,Chinese,Maths,English;
10     float Total;
11     char Name[20];
12     public:
13         Student(){}//默认构造函数 
14          Student(char name[20],int num,int chinese,int maths,int english);
15 
16 };
17 Student::Student(char name[20],int num,int chinese,int maths,int english){
18     int n;
19     for(n=0;n<strlen(name);n  )
20         Name[n]=name[n];
21     Num=num;
22     Chinese=chinese;
23     English=english;
24     Maths=maths;
25     Total=maths chinese english;
26 }
27  
28 int main()
29 {
30     int i,j;
31     int num,chinese,maths,english;
32     char name[20];
33     Student std[5];//因为有了默认构造函数所以此时编译可以通过
34         
35     for(i=0;i<5;i  )
36     {
37         cin>>name[20]>>num>>chinese>>maths>>english;
38         std[i](name[20],num,chinese,maths,english);
39         for(j=0;j<20;j  )
40         name[j]='\0';    
41         
42     }
43 }

构造函数的三个实行等第

构造函数的推行能够分为三个品级,伊始化阶段和计量阶段,开端化阶段先于总计阶段。

伊始化阶段

持有类类型(class type)的成员都会在最初化阶段初叶化,尽管该成员未有出现在构造函数的初步化列表中。

View Code

View Code

早先化阶段

所有类类型(class type)的成员都会在初阶化阶段初始化,纵然该成员未有出现在构造函数的发轫化列表中。

计量阶段

貌似用来实践构造函数体内的赋值操作,上面的代码定义五个结构体,当中Test1有构造函数,拷贝构造函数及赋值运算符,为的是方便查看结果。Test2是个测量试验类,它以Test1的靶子为成员,大家看一下Test2的构造函数是何等实践的。

全球彩票注册平台 14

struct Test1
{
    Test1() // 无参构造函数
    { 
        cout << "Construct Test1" << endl ;
    }

    Test1(const Test1& t1) // 拷贝构造函数
    {
        cout << "Copy constructor for Test1" << endl ;
        this->a = t1.a ;
    }

    Test1& operator = (const Test1& t1) // 赋值运算符
    {
        cout << "assignment for Test1" << endl ;
        this->a = t1.a ;
        return *this;
    }

    int a ;
};

struct Test2
{
    Test1 test1 ;
    Test2(Test1 &t1)
    {
        test1 = t1 ;
    }
};

全球彩票注册平台 15

调用代码

Test1 t1 ;
Test2 t2(t1) ;

输出

全球彩票注册平台 16

解释一下,第一行输出对应调用代码中第一行,构造一个Test1对象。

其次行输出对应Test2构造函数中的代码,用暗中认可的构造函数开首化对象test1,那正是所谓的初阶化阶段。(就算test1未有现身在开头化列表中,也要在开端化阶段进行开头化)

其三行输出对应Test1的赋值运算符,对test1实施赋值操作,那正是所谓的一个钱打二十七个结阶段。

地点代码在编写翻译的时候现身三个错误提醒:
[Error] no match for call to '(Student) (char&, int&, int&, int&, int&)'
该错误定位到上面那行std[i](name[20],num,chinese,maths,english);该段代码错误的因由是误以为先定义二个Student 的数组,之后调用构造函数来开展赋值,实际上,构造函数是在Student std[5];那句定义的时候就调用暗许构造函数初叶化了 (假使读者不明白构造函数的推行进度请参谋小编的上篇笔记)。全部构造函数(可以是默许构造可能非平凡构造)都以在概念的时候就调用,定义现在的调用就不叫最早化了,而是赋值。写那么些错误代码的人,分明是未曾明白构造函数是怎么实行的,
她的目标是由此巡回依次调用构造函数来实行伊始化。当然大家能够遵从她的主见来开展"无误"的编写代码,将方面的失进行出修改为std[i].Student(name[20],num,chinese,maths,english);

地方代码在编写翻译的时候出现三个不当提醒:
[Error] no match for call to '(Student) (char&, int&, int&, int&, int&)'
该错误定位到上边那行std[i](name[20],num,chinese,maths,english);该段代码错误的缘由是误感觉先定义二个Student 的数组,之后调用构造函数来拓宽赋值,实际上,构造函数是在Student std[5];那句定义的时候就调用默许构造函数初叶化了 (假如读者不掌握构造函数的施行过程请参谋小编的上篇笔记)。全体构造函数(可以是暗许构造可能非平凡构造)都以在概念的时候就调用,定义现在的调用就不叫初步化了,而是赋值。写这么些错误代码的人,显明是未有驾驭构造函数是怎么实践的,
她的目标是透过巡回依次调用构造函数来开展初阶化。当然大家能够遵照她的主张来张开"正确"的编排代码,将地点的谬误行出修改为std[i].Student(name[20],num,chinese,maths,english);

总结阶段

相似用于实施构造函数体内的赋值操作,上面包车型大巴代码定义七个结构体,当中Test1有构造函数,拷贝构造函数及赋值运算符,为的是方便查看结果。Test2是个测验类,它以Test1的对象为成员,大家看一下Test2的构造函数是何许实践的。

全球彩票注册平台 17

struct Test1
{
    Test1() // 无参构造函数
    { 
        cout << "Construct Test1" << endl ;
    }

    Test1(const Test1& t1) // 拷贝构造函数
    {
        cout << "Copy constructor for Test1" << endl ;
        this->a = t1.a ;
    }

    Test1& operator = (const Test1& t1) // 赋值运算符
    {
        cout << "assignment for Test1" << endl ;
        this->a = t1.a ;
        return *this;
    }

    int a ;
};

struct Test2
{
    Test1 test1 ;
    Test2(Test1 &t1)
    {
        test1 = t1 ;
    }
};

全球彩票注册平台 18

调用代码

Test1 t1 ;
Test2 t2(t1) ;

输出

全球彩票注册平台 19

解释一下,第一行输出对应调用代码中首先行,构造三个Test1对象。第二行输出对应Test2构造函数中的代码,用默许的构造函数起头化对象test1,那正是所谓的初步化阶段。第三行输出对应Test1的赋值运算符,对test1推行赋值操作,那正是所谓的测算阶段。

干什么采用起先化列表

伊始化类的分子有两种艺术,一是利用初阶化列表,二是在布局函数体内进行赋值操作。使用起先化列表首倘若依靠性能难点,对于内置类型,如int, float等,使用初叶化类表和在构造函数体内初阶化差异不是十分大,然则对于类类型来说,最棒使用初步化列表,为啥呢?由地点的测验能够,使用开始化列表少了一遍调用暗中认可构造函数的长河,那对于数据密集型的类来讲,是非常高效的。同样看上边的例证,大家采纳初阶化列表来贯彻Test2的构造函数

struct Test2
{
    Test1 test1 ;
    Test2(Test1 &t1):test1(t1){}
}

使用同一的调用代码,输出结果如下。

全球彩票注册平台 20

率先行输出对应 调用代码的率先行。第二行输出对应Test2的开端化列表,直接调用拷贝构造函数初阶化test1,省去了调用暗许构造函数的长河。所以贰个好的条件是,能运用最早化列表的时候尽量利用开首化列表。

那般看起来才疑似对象自己来调用构造函数进行初步化。缺憾的是,那样也是力不能及编写翻译的,出现上面包车型客车错误音信:
[Error] invalid use of 'Student::Student'

那般看起来才疑似对象自己来调用构造函数进行最初化。缺憾的是,那样也是爱莫能助编写翻译的,出现上边包车型大巴错误音讯:
[Error] invalid use of 'Student::Student'

怎么使用初叶化列表

开始化类的积极分子有三种形式,一是选取开端化列表,二是在结构函数体内开展赋值操作。使用开始化列表首假如依附质量难点,对于内置类型,如int, float等,使用早先化类表和在构造函数体内初步化差距不是极大,不过对于类类型来讲,最佳使用开始化列表,为啥吧?由地点的测量试验能够,使用开始化列表少了一遍调用默许构造函数的长河,那对于数据密集型的类来讲,是足够迅猛的。同样看上边的例证,我们接纳发轫化列表来贯彻Test2的构造函数

struct Test2
{
    Test1 test1 ;
    Test2(Test1 &t1):test1(t1){}
}

动用同一的调用代码,输出结果如下。

全球彩票注册平台 21

先是行输出对应 调用代码的第一行。第二行输出对应Test2的起先化列表,直接调用拷贝构造函数初叶化test1,省去了调用暗中认可构造函数的进程。所以贰个好的典型是,能应用初步化列表的时候尽量使用开始化列表。

什么东西必需放在最初化列表中

除了这么些之外质量难题之外,有个别时地方开始化列表是不可缺少的,以下二种状态时必得运用发轫化列表

  • 常量成员,因为常量只可以初叶化无法赋值,所以必须放在初叶化列表里面
  • 引用类型,援用必得在概念的时候最初化,何况不可能重复赋值,所以也要写在开首化列表里面
  • 向来不暗许构造函数的类类型,因为使用初步化列表能够不必调用暗许构造函数来发轫化,而是径直调用拷贝构造函数开始化。

对于从未暗中认可构造函数的类,大家看二个例证。

全球彩票注册平台 22

struct Test1
{
    Test1(int a):i(a){}
    int i ;
};

struct Test2
{
    Test1 test1 ;
    Test2(Test1 &t1)
    {
        test1 = t1 ;
    }
};

全球彩票注册平台 23

上述代码无法透过编写翻译,因为Test2类中Test1 test1;须要调用暗中同意的构造函数,可是Test1类未有无参的构造函数,然则由于Test1没有暗许的构造函数,故而编写翻译错误。精确的代码如下,使用开头化列表取代赋值操作。

struct Test2
{
    Test1 test1 ;
    Test2(Test1 &t1):test1(t1){}
}

出现这么的错误是因为,C 自个儿就要求在概念的时候系统自动调用构造函数,而指标是不可能调用构造函数的。

出现这么的一无所能是因为,C 本人将要求在概念的时候系统活动调用构造函数,而目的是无法调用构造函数的。

如何东西必需放在伊始化列表中

除了质量难题之外,有个别时场面开首化列表是必得的,以下三种境况时必须运用早先化列表

  • 常量成员,因为常量只好起首化不可能赋值,所以必需放在开首化列表里面
  • 援引类型,引用必得在概念的时候开首化,並且不能够重新赋值,所以也要写在初叶化列表里面
  • 一直不暗中认可构造函数的类类型,因为使用开首化列表能够不必调用私下认可构造函数来起头化,而是直接调用拷贝构造函数开头化。

对于未有私下认可构造函数的类,我们看三个例子。

全球彩票注册平台 24

struct Test1
{
    Test1(int a):i(a){}
    int i ;
};

struct Test2
{
    Test1 test1 ;
    Test2(Test1 &t1)
    {
        test1 = t1 ;
    }
};

全球彩票注册平台 25

如上代码不可能通过编写翻译,因为Test2的构造函数中test1 = t1这一行实在分成两步推行。

  1. 调用Test1的暗中认可构造函数来初阶化test1

  2. 调用Test1的赋值运算符给test1赋值

可是出于Test1未有私下认可的构造函数,所谓第一步不也许推行,故而编写翻译错误。正确的代码如下,使用开端化列表取代赋值操作。

struct Test2
{
    Test1 test1 ;
    Test2(Test1 &t1):test1(t1){}
}

成员变量的开头化顺序

分子是依据他们在类中冒出的各类进行伊始化的,并非遵循他们在开首化列表现身的逐个初叶化的,看代码。

struct foo
{
    int i ;
    int j ;
    foo(int x):i(x), j(i){}; // ok, 先初始化i,后初始化j
};

再看上边包车型地铁代码

struct foo
{
    int i ;
    int j ;
    foo(int x):j(x), i(j){} // i值未定义
};

此处i的值是未定义的,尽管j在伊始化列表里面出现在i前边,不过i先于j定义,所以先开始化i,但i由j初叶化,此时j尚未开始化,所以产生i的值未定义。所以,二个好的习于旧贯是,根据成员定义的顺序实行最早化。

作者:zdd

出处:

正文版权归小编和天涯论坛共有,招待转发,但未经小编同意必得保留此段评释,且在篇章页面分明地点给出原著连接,不然保留追究法律义务的职分.

建设方案:

消除方案:

成员变量的开始化顺序

分子是依据他们在类中冒出的相继举行起先化的,并不是遵从他们在伊始化列表出现的一一起始化的,看代码。

struct foo
{
    int i ;
    int j ;
    foo(int x):i(x), j(i){}; // ok, 先初始化i,后初始化j
};

再看上面包车型地铁代码

struct foo
{
    int i ;
    int j ;
    foo(int x):j(x), i(j){} // i值未定义
};

此处i的值是未定义的,即使j在最初化列表里面出现在i前边,然而i先于j定义,所以先起先化i,但i由j起先化,此时j尚未初始化,所以造成i的值未定义。所以,一个好的习贯是,遵照成员定义的依次进行伊始化。

1、能够在概念的时候一向初阶化,为了方便的辨证难点,大家把上面包车型大巴Student std[5];那句代码中改为1个数组成分,for循环去掉,
就成为下边包车型客车代码了(这段代码仅仅c 11支撑):

1、能够在概念的时候一直开始化,为了便利的证实难点,大家把地点的Student std[5];那句代码中改为1个数组成分,for循环去掉,
就改为下边包车型大巴代码了(这段代码仅仅c 11支持):

本文由全球彩票平台发布于全球彩票注册平台编程,转载请注明出处:全球彩票注册平台开始化列表,构造函数之伊始

TAG标签: 全球彩票平台
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。