C++构造函数初始化列表与构造函数中的赋值的区别

         C++类中成员变量的初始化有两种方式：

          构造函数初始化列表和构造函数体内赋值。下面看看两种方式有何不同。

         成员变量初始化的顺序是按照在那种定义的顺序。

1、内部数据类型（char，int……指针等）

[cpp]  view plain  copy

1. class Animal  
2. {  
3. public:  
4.     Animal(int weight,int height):       //A初始化列表  
5.       m_weight(weight),  
6.       m_height(height)  
7.     {  
8.     }  
9.     Animal(int weight,int height)       //B函数体内初始化  
10.     {  
11.         m_weight = weight;  
12.         m_height = height;  
13.     }  
14. private:  
15.     int m_weight;  
16.     int m_height;  
17. };  

对于这些内部类型来说，基本上是没有区别的，效率上也不存在多大差异。

当然A和B方式不能共存的。

 

2、无默认构造函数的继承关系中

[cpp]  view plain  copy

1. class Animal  
2. {  
3. public:  
4.     Animal(int weight,int height):        //没有提供无参的构造函数   
5.       m_weight(weight),  
6.       m_height(height)  
7.     {  
8.     }  
9. private:  
10.     int m_weight;  
11.     int m_height;  
12. };  
13.   
14. class Dog: public Animal  
15. {  
16. public:  
17.     Dog(int weight,int height,int type)   //error 构造函数 父类Animal无合适构造函数  
18.     {  
19.     }  
20. private:  
21.     int m_type;  
22. };  

上面的子类和父类编译会出错：

因为子类Dog初始化之前要进行父类Animal的初始化，但是根据Dog的构造函数，没有给父类传递参数，使用了父类Animal的无参数构造函数。而父类Animal提供了有参数的构造函数，这样编译器就不会给父类Animal提供一个默认的无参数的构造函数了，所以编译时报错，说找不到合适的默认构造函数可用。要么提供一个无参数的构造函数，要么在子类的Dog的初始化列表中给父类Animal传递初始化参数，如下：

[cpp]  view plain  copy

1. class Dog: public Animal  
2. {  
3. public:  
4.     Dog(int weight,int height,int type):  
5.         Animal(weight,height)         //必须使用初始化列表增加对父类的初始化  
6.     {  
7.         ;  
8.     }  
9. private:  
10.     int m_type;  
11. };  

 

3、类中const常量，必须在初始化列表中初始，不能使用赋值的方式初始化

[cpp]  view plain  copy

1. class Dog: public Animal  
2. {  
3. public:  
4.     Dog(int weight,int height,int type):  
5.         Animal(weight,height),   
6.         LEGS(4)                //必须在初始化列表中初始化  
7.     {  
8.         //LEGS = 4;           //error  
9.     }  
10. private:  
11.     int m_type;  
12.     const int LEGS;  
13. };  

4、包含有自定义数据类型（类）对象的成员初始化        

[cpp]  view plain  copy

1. class Food  
2. {  
3. public:  
4.     Food(int type = 10)  
5.     {  
6.         m_type = 10;  
7.     }  
8.     Food(Food &other)                 //拷贝构造函数  
9.     {  
10.         m_type = other.m_type;  
11.     }  
12.     Food & operator =(Food &other)      //重载赋值=函数  
13.     {  
14.         m_type = other.m_type;  
15.         return *this;  
16.     }  
17. private:  
18.     int m_type;  
19. };  
20.   
21. （1）构造函数赋值方式 初始化成员对象m_food  
22. class Dog: public Animal  
23. {  
24. public:  
25.     Dog(Food &food)  
26.       //:m_food(food)    
27.     {  
28.         m_food = food;               //初始化 成员对象  
29.     }  
30. private:  
31.     Food m_food;  
32. };  
33. //使用  
34. Food fd;  
35. Dog dog(fd);   //  
36. Dog dog(fd);结果：  
37. 先执行了   对象类型构造函数Food(int type = 10)——>   
38. 然后在执行 对象类型构造函数Food & operator =(Food &other)  
39. 想象是为什么？  
40.   
41. （2）构造函数初始化列表方式  
42. class Dog: public Animal  
43. {  
44. public:  
45.     Dog(Food &food)  
46.       :m_food(food)                  //初始化 成员对象  
47.     {  
48.         //m_food = food;                 
49.     }  
50. private:  
51.     Food m_food;  
52. };  
53. //使用  
54. Food fd;  
55. Dog dog(fd);   //  
56. Dog dog(fd);结果：执行Food(Food &other)拷贝构造函数完成初始化  

不同的初始化方式得到不同的结果：

　　　　　　明显构造函数初始化列表的方式得到更高的效率。