第12篇:C++多态中的Upcast类型转换

在前文我们已经用一个非常详实用的例子介绍了静态绑定和动态绑定的含义以及他们的差异，从本篇我们开始讨论面向对象版本的动态绑定技术的细节问题。但开始之前，我们必须回顾类型转换基本的知识,因为C++类继承的多态技术中,类对象动态绑定成员(属性和方法)时,会伴随着类型转换。这也是静态和动态绑定之间的主要区别。因此，动态绑定的讨论必须涵盖类型转换(Type-cast)的话题

我们先从基本数据类型的类型转换开始吧。

int I=3;
double d=2.5;
double result=d/i;  //i会被隐式向上转换为double

类型转换可以是显式的和隐式的，考虑如下代码，

 int I=3;
 double d=2.5;
//隐式转换,从类型尺寸小向类型尺寸大的转换,编译器乐意接受
 d=I; 
//隐式转换,精度会丢失,某些编译
//器会报错,但编译还是能通过
 i=d; 
 printf("d=%.2f\n",d);
 printf("sizeof d is %d\n",sizeof(d));

d=i，这是隐式转换,编译器乐意接受,因为精度不变并且内存空间由4字节扩充为8字节.
i=d, 部分C/C++编译器甚至默许你这么做,8字节的数字转化为4字节，精度会丢失。整数部分会被保留下来,小数点后的会被丢弃。

OK,如果上面的类型转化你没疑问的话，我们现在探讨一下C++用户自定义类型的类型转换，下面是一个非常好的反面教材。

下面声明了两个类A和类B，他们毫不相干(不存在任何继承关系)

#include <iostream>

class A{int i=1;};
class B{double k=1.1;};

int main(void){
    A a;
    B b;
    A *p=&a;
    B *q=&b;
   ....
}

错误的例子

b=a; //存在隐式的类型转换吗？
b=(A)a;//存在显式的类型转换吗？

首先我们尝试像前面的操作对用户自定义类型的对象赋值到另外一个类的对象。编译器是不买你的帐的直接报错。

错误的示例

这个反面教程的用意其实当尝试执行a=b,那么其实质就是调用了对象a的operator =()操作符函数,即等价于如下代码

a.operator=(const B &b);

显然,类A并不存在一个operator=()函数联系类A实例和类B实例的重载版本，除非你人为地去实现这样的重载版本。

同理,如下类A实例的指针p和类B实例的指针q,都不能这样进行隐式的类型转换的。

p=q;  //错误
q=p;  //错误

那么，再次将类B的实例强制转换A类型,尝试如下

 std::cout<<"实例B之前的类型尺寸:"<<sizeof(*q)<<std::endl;
 p=(A*)q;
 std::cout<<"实例B之后的类型尺寸:"<<sizeof(*p)<<std::endl;
 std::cout<<"p->i:"<<p->i<<std::endl;

傻眼了吧!,C++编译器允许你这么做，但我提醒就是一种很沙雕的行为，这里仅做反面教材展示!!

那么对用户自定义类型的强制类型转换在内存的底层做了写什么呢？我们先看看未执行强制转换前的内存状态。

从大尺寸的类B强制类型转换类A，主要发生了如下内存操作

从低地址位开始，赋值操作符右边的源操作数(即类实例B)依次从低地向高地址开始拷贝数据到赋值操作符左边的目标操作数对应顺序的字节位。
若目标操作数的类型尺寸小于源操作数的类型尺寸,则以目标操作数的类型尺寸为准，目标操作数的超出源操作数类型尺寸的剩余高地址部分的字节数据会被丢弃。

我们看看用户自定义数据类型从小尺寸到大尺寸转换的底层内存操作

q=(B*)p;

若目标操作数的类型尺寸大于源操作数的的尺寸类型，则目标操作数的所有字节数据会按低地址到高地址的顺序依次拷贝到目标操作数,目标操作数超出源操作数尺寸的剩余高地址部分保持字节数据,编译器会以字节0填充。

上面的反面示例,我们通过将两个毫不相关的类实例相互强制转换会产生不可预知的后果,赋值操作符左边的类实例的数据完全被篡改，这是一种非常危险的行为。我们也通过这个示例分析了通过类实例的指针执行强制类型转换的更底层的内存操作。

继承链中的类型转换

Ok,了解类型转换的底层内存操作之后，我们继续考探讨继承中的类型转换，首先下面示例代码是我之前用过的。

#include <iostream>
#include <string>

class Employee{
  private:
    bool p_isValid=true;
  public:
    std::string m_name;
    double m_salary=1500;
    bool m_iService=true;

    Employee(){}
    Employee(const std::string &name):m_name(name){}
    Employee(const std::string &name,double salary):
    m_name(name),
    m_salary(salary){}

    virtual void show_info(){
      std::cout<<"显示员工信息"<<std::endl;
    }

    void show_status(){
      std::cout<<"当前员工的账户状态:";
      if(!p_isValid){
        std::cout<<"已禁用"<<std::endl;
      }else{
        std::cout<<"已启用"<<std::endl;
      }
    }

    virtual void add_salary(double k){
      m_salary+=k;
      std::cout<<m_name<<" 加薪后:¥"<<m_salary<<std::endl;
    }
    
    void show_salary(){
      std::cout<<m_name<<":¥"<<m_salary<<std::endl;
    }
    
    virtual void search(){
      std::cout<<"查找用户功能"<<std::endl;
    }
};

下面的Manager类和Supervisor类的基类是Employee类。

class Manager:public Employee{
  public:
    int level=0;
    std::string group="administrator";
    Manager(const std::string &name){
      m_name=name;
      m_salary=10000;
    }

    virtual void depart_mgnt(){
      std::cout<<"部门管理功能"<<std::endl;
    }

    void show_undering(){
      std::cout<<"直属员工管理"<<std::endl;
    }
};

class Supervisor:public Employee{
  public:
    Supervisor(const std::string &name){
      m_name=name;
      m_salary=5000;
    }
};

我们看看以下调用代码

int main(void){
  std::string e_name="职员";
  std::string m_name="经理";

  Employee *e=new Employee(e_name);
  Manager *m=new Manager(m_name);
  
  Employee *e2=m; //upcast
}

首先看程序输出，从继承链中,这条命令的语义从Manager类的实例到Employee类实例的转换。

Employee *e2=m;

但你真正理解它背后的内存含义吗？这对于C++编译是合法的。为什么呢？

类型转换的内存原理

其实原因很简单，上面实例我们有Employee类实例，并且思考一下Manager类实例的内存中有什么内容？在继承中,派生类都从父类获得一份公开(public)或受保护(protected)的父类数据成员(属性)的副本,也就是说,每个派生类对象内部都持有一份“特殊版本”的父类实例的信息。

因此，本例中Manager对象内部有一个Employee对象的副本,当然该副本也是基类的实例,其内存地址0x6030a0-0x6030c3这片内存区域的属性数据副本就是从Employee实例继承(拷贝)而来,并且e2指向的对象内存地址和Manager类对象m是一样的0x6030a0,但e2的类型尺寸被限定为40字节。

Manager对象的内存细节

上图我不需要再解析内存方面的细节。至于“特殊”,就是派生类对象可能对它自己持有的父类的数据成员副本已经重新赋值.类型转换后的Employee对象e2,它只能访问的就只有0x6030a0到0x6030c3这片内存区域,因为编译器已经从类型尺寸上锁定了Employee类型的实例为40个字节。不相信吗？可以考虑以下的代码

 Employee *e2=m;
//类型转换后只有,编译器只认定e2有40个字节
 std::cout<<sizeof(*e2)<<std::endl;
//可以正常访问,因为show_salary继承在基类
 e2->show_salary(); 

//不可访问,因为level是Manager类实例原创的数据成员
 e2->level;
//不可访问,因为show_undering方法是
//Manager类实例原创的成员函数
 e2->show_undering();

超过40个字节内存区域,即0x6030c4-0x6030cf这片内存区域中的数据,Employee没有任何访问权限,因为这是Manager实例m的专属内存区域。

停下来....思考一下吧！到这里,你是否得到一些启发?不论C/C++还是Java静态语言中你如何理解"类型"这个名词？

不同数据类型都有其编译时字节对齐操作后的固有尺寸的内存空间,结合该内存空间的首个字节的内存地址就能表示一个数据类型的实例能够支配的数据空间。

Ok,说了那么多,我们定义一下从派生类到基类的类型转换,我们称为类型向上转换(Upcast)，Upcast在类型转换过程中是安全的,从上面的示例中我们看到Upcast操作仅仅是拷贝了派生类中的基类实例副本，派生类所属的内存区域对于基类对象是一无所知的。

upcast的副作用

返回示例中，为何当Elememt的实例e2尝试调用show_undering()就会报错,这个问题突出了很少人会关注的问题-“对象切片(Object Slicing)”

当将派生类对象分配给基类对象(Upcast)时,派生类对象的所有成员都将复制到基类对象，但派生类原创的成员(属性和方法),这些成员被编译器"阉割"掉。这就是所谓的对象切片(Object Slicing)，目前我们仅引用这个概念,本文不对“对象切片”展开论述。

另外你想通过GDB调试器的内存分析编译器阉割派生类原创的非虚函数是非常困难的,C++编译器这一操作非常隐蔽。

对象切片对成员函数继承的影响？
回答这个问题之前,首先要理解继承链中派生类从基类继承的成员函数，这一继承动作的实质是什么？下面是我的理解。

父类公开或受保护的成员函数(包括虚函数)同样是被派生类继承,但继承的只是父类成员函数的调用权,在继承关系中,派生类从基类继承的成员函数实质上继承的是存储在代码段(Code Segment)内存区中,基类可共享的成员函数的内存地址，因为每个成员函数都有一个唯一的内存地址。

那么派生通过继承得到的基类成员函数的地址,在对象切片的作用下有三种情况。

对于非虚成员函数来说,基类对象只能得到基类原创定义且可被继承的成员函数的地址,派生类原创定义的成员函数的地址,对于upcast操作后的基类对象是不可见的。
对于虚成员函数来说，如下三种情况,对于基类对象运行时绑定哪个虚成员函数的地址,是依据填入基类的虚表的函数地址来判断的。
- 若该函数是派生类原创定义的,对于upcast操作后的基类对象是不可见的。
- 若该函数是基类原创定义且未被派生类重写，对于upcast操作后的基类对象,该基类版本的虚函数可见。
- 若该函数是基类原创定义且已被派生类重写,对与upcast操作后的基类对象,该派生类版本的虚成员函数可见。

ss17.png

小结

本篇我们通过详细的例子循序渐进地阐述了Upcast类型转换对于继承链中的用户自定类型的实例的影响以及Upcast操作的内存操作细节，同时也从反面介绍了一些不安全的类型转换。理解这些类型转换操作可以扩充了你对C++编译器在继承中更多的底层操作。关于动态绑定的操作隐含的类型操作是安全的，因为upcast并没有修改派生类的内容，仅仅是拷贝派生类中所持有的基类实例副本。