day4 4.9(向上转型)派生类赋值给基类

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

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

数据类型转换的前提是,编译器知道如何对数据进行取舍;大的变小,直接丢弃就可以,小的变大的多出来的内存不知道如何填充

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

  1. 向上转型非常安全,可以由编译器自动完成;
  2. 向下转型有风险,需要程序员手动干预。本节只介绍向上转型,向下转型将在后续章节介绍;

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

#include <cstdio>

using namespace std;

class A {
public:
    A(int a);
    void print() const;
protected:
    int m_a;
};

A::A(int a) : m_a(a) {}
void A::print() const {
    printf("class A: m_a = %d\n", m_a);
}

class B : public A {
public:
    B(int a, int b);
    void print() const;
private:
    int m_b;
};

B::B(int a, int b) : A(a), m_b(b) {}
void B::print() const {
    printf("class B: m_a = %d, m_b = %d\n", m_a, m_b);
}

int main() {
    A a(1);
    B b(11, 22);
    a.print();
    b.print();

    printf("----------------\n");

    a = b;//向上转型,大的变成小的
    a.print();
    b.print();

    return 0;
}

运行结果:

class A: m_a = 1
class B: m_a = 11, m_b = 22
----------------
class A: m_a = 11
class B: m_a = 11, m_b = 22

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

将派生类对象赋值给基类对象时,会舍弃派生类新增的成员,也就是“大材小用”;

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

要理解这个问题,还得从赋值的本质入手。

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

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

除了可以将派生类对象赋值给基类对象(对象变量之间的赋值),还可以将派生类指针赋值给基类指针(对象指针之间的赋值);

我们先来看一个多继承的例子:基类 A 拥有成员 m_a;中间派生类 B 继承于 A,并添加了新成员 m_b;基类 C 拥有成员 m_c;最终派生类 D 继承 B 和 C;

#include <cstdio>

using namespace std;

class A {
public:
    A(int a);
    void print() const;
protected:
    int m_a;
};

A::A(int a) : m_a(a) {}
void A::print() const {
    printf("class A: m_a = %d\n", m_a);
}

class B : public A {
public:
    B(int a, int b);
    void print() const;
protected:
    int m_b;
};

B::B(int a, int b) : A(a), m_b(b) {}
void B::print() const {
    printf("class B: m_a = %d, m_b = %d\n", m_a, m_b);
}

class C {
public:
    C(int c);
    void print() const;
protected:
    int m_c;
};

C::C(int c) : m_c(c) {}
void C::print() const {
    printf("class C: m_c = %d\n", m_c);
}

class D : public B, public C {
public:
    D(int a, int b, int c, int d);
    void print() const;
private:
    int m_d;
};

D::D(int a, int b, int c, int d) : B(a, b), C(c), m_d(d) {}
void D::print() const {
    printf("class D: m_a = %d, m_b = %d, m_c = %d, m_d = %d\n", m_a, m_b, m_c, m_d);
}

int main() {
    A *pa = new A(1);
    pa -> print();
    B *pb = new B(11, 22);
    pb -> print();
    C *pc = new C(3);
    pc -> print();

    D *pd = new D(110, 114, 119, 120);
    pd -> print();
    printf("--------------------------\n");

    pa = pd;//pa是A类型指针,基类
    pa -> print();
    pb = pd;
    pb -> print();
    pc = pd;
    pc -> print();

    printf("---------------------------\n");
    printf("pa = %p\npb = %p\npc = %p\npd = %p\n", pa, pb, pc, pd);

    return 0;
}

运行结果:

class A: m_a = 1
class B: m_a = 11, m_b = 22
class C: m_c = 3
class D: m_a = 110, m_b = 114, m_c = 119, m_d = 120
--------------------------
class A: m_a = 110
class B: m_a = 110, m_b = 114
class C: m_c = 119
---------------------------
pa = 0xb61aee4090
pb = 0xb61aee4090
pc = 0xb61aee4098
pd = 0xb61aee4090

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

  1. 通过基类指针访问派生类的成员
    将派生类指针 pd 赋值给了基类指针 pa,从运行结果可以看出,调用 print() 函数时虽然使用了派生类的成员变量,但是 print() 函数本身却是基类的;也就是说,将派生类指针赋值给基类指针时,通过基类指针只能使用派生类的成员变量,但不能使用派生类的成员函数,pb、pc 也是一样的情况;
    这是因为,调用哪个类的函数不是由指针指向的数据为判断标准,而是决定于指针的类型,如果指针的类型是A *,那么就调用类 A 的函数,如果是D *,就调用类 D 的函数;
    概括起来说就是:编译器通过指针来访问成员变量,指针指向哪个对象就使用哪个对象的数据;编译器通过指针的类型来访问成员函数,指针属于哪个类的类型就使用哪个类的函数。

  2. 赋值后值不一致的情况
    本例中我们将最终派生类的指针 pd 分别赋值给了基类指针 pa、pb、pc,按理说它们的值应该相等,都指向同一块内存,但是运行结果却有力地反驳了这种推论,只有 pa、pb、pd 三个指针的值相等,pc 的值比它们都大。也就是说,执行pc = pd;语句后,pc 和 pd 的值并不相等,这是因为在赋值前,编译器会进行某些处理,就如同将 float 类型的 3.14 赋值给 int 类型的变量时,编译器会直接舍弃小数点后的值,最终变为 3;对象指针之间的赋值也是这个道理;因为A->B,B->D,C->D,B->D,所以A,B,D理所应当同一块内存,C与A肯定存在偏移,我们通过继承类的对象内存模型可以推导。

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

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

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

将派生类指针赋值给基类指针时到底发生了什么

通过上节最后一个例子我们发现,将派生类的指针赋值给基类的指针后,它们的值有可能相等,也有可能不相等;

我们通常认为,赋值就是将一个变量的值交给另外一个变量,这种想法虽然没错,但是有一点要注意,就是赋值以前编译器可能会对现有的值进行处理;

例如将 double 类型的值赋给 int 类型的变量,编译器会直接抹掉小数部分,导致赋值运算符两边变量的值不相等;

将派生类的指针赋值给基类的指针时也是类似的道理,编译器也可能会在赋值前进行处理;

要明确的一点是,对象的指针必须要指向对象的起始位置;这也是第二个代码例子里C的地址与其他不一样的原因。

  1. 对于 A 类和 B 类来说,它们的子对象的起始地址和 D 类对象一样,所以将 pd 赋值给 pa、pb 时不需要做任何调整,直接传递现有的值即可;
  2. 而 C 类子对象距离 D 类对象的开头有一定的偏移,将 pd 赋值给 pa 时要加上这个偏移,这样 pc 才能指向 C 类子对象的起始位置;
    也就是说,执行pc = pd;语句时编译器对 pd 的值进行了调整,才导致 pc、pd 的值不同;
发布了85 篇原创文章 · 获赞 56 · 访问量 5157
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 像素格子 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览