C++将派生类赋值给基类(向上转型)

Posted C语言学习联盟

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C++将派生类赋值给基类(向上转型)相关的知识,希望对你有一定的参考价值。


在 C/ C++  中经常会发生数据类型的转换,例如将 int 类型的数据赋值给 float 类型的变量时,编译器会先把 int 类型的数据转换为 float 类型再赋值;反过来,float 类型的数据在经过类型转换后也可以赋值给 int 类型的变量。

数据类型转换的前提是,编译器知道如何对数据进行取舍。例如:
    
      
      
    
  1. int a = 10.9 ;
  2. printf ( "%d \n " , a );
输出结果为 10,编译器会将小数部分直接丢掉(不是四舍五入)。再如:
    
      
      
    
  1. float b = 10 ;
  2. printf ( "%f \n " , b );
输出结果为 10.000000,编译器会自动添加小数部分。

类其实也是一种数据类型,也可以发生数据类型转换,不过这种转换只有在基类和派生类之间才有意义,并且只能将派生类赋值给基类,包括将派生类对象赋值给基类对象、将派生类指针赋值给基类指针、将派生类引用赋值给基类引用,这在 C++ 中称为向上转型( Upcasting )。相应地,将基类赋值给派生类称为向下转型( Downcasting )。

向上转型非常安全,可以由编译器自动完成;向下转型有风险,需要程序员手动干预。本节只介绍向上转型,向下转型将在后续章节介绍。
向上转型和向下转型是面向对象编程的一种通用概念,它们也存在于 Java、C# 等编程语言中。

将派生类对象赋值给基类对象

下面的例子演示了如何将派生类对象赋值给基类对象:
    
      
      
    
  1. #include <iostream>
  2. u sin g namespace std ;
  3. //基类
  4. class A {
  5. public :
  6. A ( int a );
  7. public :
  8. void display ();
  9. public :
  10. int m_a ;
  11. } ;
  12. A :: A ( int a ): m_a (a ) { }
  13. void A :: display () {
  14. cout << "Class A: m_a=" <<m_a <<endl ;
  15. }
  16. //派生类
  17. class B : public A {
  18. public :
  19. B ( int a , int b );
  20. public :
  21. void display ();
  22. public :
  23. int m_b ;
  24. } ;
  25. B :: B ( int a , int b ): A (a ), m_b (b ) { }
  26. void B :: display () {
  27. cout << "Class B: m_a=" <<m_a << ", m_b=" <<m_b <<endl ;
  28. }
  29. int main () {
  30. A a ( 10 );
  31. B b ( 66 , 99 );
  32. //赋值前
  33. a . display ();
  34. b . display ();
  35. cout << "--------------" <<endl ;
  36. //赋值后
  37. a = b ;
  38. a . display ();
  39. b . display ();
  40. return 0 ;
  41. }
运行结果:
Class A: m_a=10
Class B: m_a=66, m_b=99
----------------------------
Class A: m_a=66
Class B: m_a=66, m_b=99

本例中 A 是基类, B 是派生类,a、b 分别是它们的对象,由于派生类 B 包含了从基类 A 继承来的成员,因此可以将派生类对象 b 赋值给基类对象 a。通过运行结果也可以发现,赋值后 a 所包含的成员变量的值已经发生了变化。

赋值的本质是将现有的数据写入已分配好的内存中,对象的内存只包含了成员变量,所以对象之间的赋值是成员变量的赋值,成员函数不存在赋值问题。 运行结果也有力地证明了这一点,虽然有 a=b; 这样的赋值过程,但是 a.display() 始终调用的都是 A 类的 display() 函数。换句话说,对象之间的赋值不会影响成员函数,也不会影响 this 指针。

将派生类对象赋值给基类对象时,会舍弃派生类新增的成员,也就是“大材小用”,如下图所示:
C++将派生类赋值给基类(向上转型)
可以发现,即使将派生类对象赋值给基类对象,基类对象也不会包含派生类的成员,所以依然不同通过基类对象来访问派生类的成员。对于上面的例子,a.m_a 是正确的,但 a.m_b 就是错误的,因为 a 不包含成员 m_b。

这种转换关系是不可逆的,只能用派生类对象给基类对象赋值,而不能用基类对象给派生类对象赋值。 理由很简单,基类不包含派生类的成员变量,无法对派生类的成员变量赋值。同理,同一基类的不同派生类对象之间也不能赋值。

要理解这个问题,还得从赋值的本质入手。赋值实际上是向内存填充数据,当数据较多时很好处理,舍弃即可;本例中将 b 赋值给 a 时(执行 a=b; 语句),成员 m_b 是多余的,会被直接丢掉,所以不会发生赋值错误。但当数据较少时,问题就很棘手,编译器不知道如何填充剩下的内存;如果本例中有 b= a; 这样的语句,编译器就不知道该如何给变量 m_b 赋值,所以会发生错误。

将派生类指针赋值给基类指针

除了可以将派生类对象赋值给基类对象(对象变量之间的赋值),还可以将派生类指针赋值给基类指针(对象指针之间的赋值)。我们先来看一个多继承的例子,继承关系为:
C++将派生类赋值给基类(向上转型)
下面的代码实现了这种继承关系:
    
      
      
    
  1. #include <iostream>
  2. using namespace std ;
  3. //基类A
  4. class A {
  5. public :
  6. A ( int a );
  7. public :
  8. void display ();
  9. protected :
  10. int m_a ;
  11. } ;
  12. A :: A ( int a ): m_a (a ) { }
  13. void A :: display () {
  14. cout << "Class A: m_a=" <<m_a <<endl ;
  15. }
  16. //中间派生类B
  17. class B : public A {
  18. public :
  19. B ( int a , int b );
  20. public :
  21. void display ();
  22. protected :
  23. int m_b ;
  24. } ;
  25. B :: B ( int a , int b ): A (a ), m_b (b ) { }
  26. void B :: display () {
  27. cout << "Class B: m_a=" <<m_a << ", m_b=" <<m_b <<endl ;
  28. }
  29. //基类C
  30. class C {
  31. public :
  32. C ( int c );
  33. public :
  34. void display ();
  35. protected :
  36. int m_c ;
  37. } ;
  38. C :: C ( int c ): m_c (c ) { }
  39. void C :: display () {
  40. cout << "Class C: m_c=" <<m_c <<endl ;
  41. }
  42. //最终派生类D
  43. class D : public B , public C {
  44. public :
  45. D ( int a , int b , int c , int d );
  46. public :
  47. void display ();
  48. private :
  49. int m_d ;
  50. } ;
  51. D :: D ( int a , int b , int c , int d ): B (a , b ), C (c ), m_d (d ) { }
  52. void D :: display () {
  53. cout << "Class D: m_a=" <<m_a << ", m_b=" <<m_b << ", m_c=" <<m_c << ", m_d=" <<m_d <<endl ;
  54. }
  55. int main () {
  56. A *pa = new A ( 1 );
  57. B *pb = new B ( 2 , 20 );
  58. C *pc = new C ( 3 );
  59. D *pd = new D ( 4 , 40 , 400 , 4000 );
  60. pa = pd ;
  61. pa -> display ();
  62. pb = pd ;
  63. pb -> display ();
  64. pc = pd ;
  65. pc -> display ();
  66. cout << "-----------------------" <<endl ;
  67. cout << "pa=" <<pa <<endl ;
  68. cout << "pb=" <<pb <<endl ;
  69. cout << "pc=" <<pc <<endl ;
  70. cout << "pd=" <<pd <<endl ;
  71. return 0 ;
  72. }
运行结果:
Class A: m_a=4
Class B: m_a=4, m_b=40
Class C: m_c=400
-----------------------
pa=0x9b17f8
pb=0x9b17f8
pc=0x9b1800
pd=0x9b17f8

本例中定义了多个对象指针,并尝试将派生类指针赋值给基类指针。与对象变量之间的赋值不同的是,对象指针之间的赋值并没有拷贝对象的成员,也没有修改对象本身的数据,仅仅是改变了指针的指向。

1) 通过基类指针访问派生类的成员

请读者先关注第 61行代码,我们将派生类指针 pd 赋值给了基类指针 pa,从运行结果可以看出,调用 display() 函数时虽然使用了派生类的成员变量,但是 display() 函数本身却是基类的。也就是说,将派生类指针赋值给基类指针时,通过基类指针只能使用派生类的成员变量,但不能使用派生类的成员函数,这看起来有点不伦不类,究竟是为什么呢?第 63、65 行代码也是类似的情况。

pa 本来是基类 A 的指针,现在指向了派生类 D 的对象,这使得隐式指针 this 发生了变化,也指向了 D 类的对象,所以最终在 display() 内部使用的是 D 类对象的成员变量,相信这一点不难理解。

编译器虽然通过指针的指向来访问成员变量,但是却不通过指针的指向来访问成员函数:编译器通过指针的类型来访问成员函数。对于 pa,它的类型是 A,不管它指向哪个对象,使用的都是 A 类的成员函数。

概括起来说就是:编译器通过指针来访问成员变量,指针指向哪个对象就使用哪个对象的数据;编译器通过指针的类型来访问成员函数,指针属于哪个类的类型就使用哪个类的函数。

2) 赋值后值不一致的情况

本例中我们将最终派生类的指针 pd 分别赋值给了基类指针 pa、pb、pc,按理说它们的值应该相等,都指向同一块内存,但是运行结果却有力地反驳了这种推论,只有 pa、pb、pd 三个指针的值相等,pc 的值比它们都大。也就是说,执行 pc = pd; 语句后,pc 和 pd 的值并不相等。

将派生类引用赋值给基类引用

引用在本质上是通过指针的方式实现的 ,既然基类的指针可以指向派生类的对象,那么我们就有理由推断:基类的引用也可以指向派生类的对象,并且它的表现和指针是类似的。

修改上例中 main() 函数内部的代码,用引用取代指针:
    
      
      
    
  1. int main () {
  2. D d ( 4 , 40 , 400 , 4000 );
  3. A &ra = d ;
  4. B &rb = d ;
  5. C &rc = d ;
  6. ra . display ();
  7. rb . display ();
  8. rc . display ();
  9. return 0 ;
  10. }
运行结果:
Class A: m_a=4
Class B: m_a=4, m_b=40
Class C: m_c=400

ra、rb、rc 是基类的引用,它们都引用了派生类对象 d,并调用了 display() 函数,从运行结果可以发现,虽然使用了派生类对象的成员变量,但是却没有使用派生类的成员函数,这和指针的表现是一样的。

最后需要注意的是,向上转型后通过基类的对象、指针、引用只能访问从基类继承过去的成员(包括成员变量和成员函数),不能访问派生类新增的成员。

小编整理了一套C语言学习资料,需要的话可以私信@C语言学习联盟回复领取资料即可,欢迎大家关注,有时间会及时分享相关技术博文,你的关注和点赞对小编都很重要,谢谢各位动动发财的手指点点关注啦~