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

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

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

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

1、内部数据类型(char,int……指针等)


  
  
  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、无默认构造函数的继承关系中


 
 
  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. class Dog: public Animal
  14. {
  15. public:
  16. Dog( int weight, int height, int type) //error 构造函数 父类Animal无合适构造函数
  17. {
  18. }
  19. private:
  20. int m_type;
  21. };

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


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


  
  
  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常量,必须在初始化列表中初始,不能使用赋值的方式初始化


 
 
  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、包含有自定义数据类型(类)对象的成员初始化        


 
 
  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. 1)构造函数赋值方式 初始化成员对象m_food
  21. class Dog: public Animal
  22. {
  23. public:
  24. Dog(Food &food)
  25. //:m_food(food)
  26. {
  27. m_food = food; //初始化 成员对象
  28. }
  29. private:
  30. Food m_food;
  31. };
  32. //使用
  33. Food fd;
  34. Dog dog(fd); //
  35. Dog dog(fd);结果:
  36. 先执行了 对象类型构造函数Food( int type = 10)——>
  37. 然后在执行 对象类型构造函数Food & operator =(Food &other)
  38. 想象是为什么?
  39. 2)构造函数初始化列表方式
  40. class Dog: public Animal
  41. {
  42. public:
  43. Dog(Food &food)
  44. :m_food(food) //初始化 成员对象
  45. {
  46. //m_food = food;
  47. }
  48. private:
  49. Food m_food;
  50. };
  51. //使用
  52. Food fd;
  53. Dog dog(fd); //
  54. Dog dog(fd);结果:执行Food(Food &other)拷贝构造函数完成初始化

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

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

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值