C++ 向上转型

喜欢ヅ旅行 2023-07-14 10:49 17阅读 0赞

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

数据类型转换的前提是，编译器知道如何对数据进行取舍。例如：

int a = 10.9;
    printf("%d\n", a);

输出结果为 10，编译器会将小数部分直接丢掉（不是四舍五入）。再如：

float b = 10;
    printf("%f\n", b);

输出结果为 10.000000，编译器会自动添加小数部分。

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

向上转型非常安全，可以由编译器自动完成；向下转型有风险，需要程序员手动干预。

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

下面的例子演示了如何将派生类对象赋值给基类对象：

#include <iostream>
    using namespace std;
    
    //基类
    class A{ 
    public:
        A(int a);
    public:
        void display();
    public:
        int m_a;
    };
    A::A(int a): m_a(a){  }
    void A::display(){ 
        cout<<"Class A: m_a="<<m_a<<endl;
    }
    
    //派生类
    class B: public A{ 
    public:
        B(int a, int b);
    public:
        void display();
    public:
        int m_b;
    };
    B::B(int a, int b): A(a), m_b(b){  }
    void B::display(){ 
        cout<<"Class B: m_a="<<m_a<<", m_b="<<m_b<<endl;
    }
    
    
    int main(){ 
        A a(10);
        B b(66, 99);
        //赋值前
        a.display();
        b.display();
        cout<<"--------------"<<endl;
        //赋值后
        a = b;
        a.display();
        b.display();
    
        return 0;
    }

运行结果：

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 所包含的成员变量的值已经发生了变化。

赋值的本质是将现有的数据写入已分配好的内存中，对象的内存只包含了成员变量，所以对象之间的赋值是成员变量的赋值，成员函数不存在赋值问题。

将派生类对象赋值给基类对象时，会舍弃派生类新增的成员，也就是“大材小用”，如下图所示：

![在这里插入图片描述][20200314150431224.png]

可以发现，即使将派生类对象赋值给基类对象，基类对象也不会包含派生类的成员，所以依然不同通过基类对象来访问派生类的成员。

这种转换关系是不可逆的，**只能用派生类对象给基类对象赋值，而不能用基类对象给派生类对象赋值**。

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

除了可以将派生类对象赋值给基类对象（对象变量之间的赋值），还可以将派生类指针赋值给基类指针（对象指针之间的赋值）。我们先来看一个多继承的例子，继承关系为：

![在这里插入图片描述][20200314150655678.jpg]  
下面的代码实现了这种继承关系：

#include <iostream>
    using namespace std;
    
    //基类A
    class A{ 
    public:
        A(int a);
    public:
        void display();
    protected:
        int m_a;
    };
    A::A(int a): m_a(a){  }
    void A::display(){ 
        cout<<"Class A: m_a="<<m_a<<endl;
    }
    
    //中间派生类B
    class B: public A{ 
    public:
        B(int a, int b);
    public:
        void display();
    protected:
        int m_b;
    };
    B::B(int a, int b): A(a), m_b(b){  }
    void B::display(){ 
        cout<<"Class B: m_a="<<m_a<<", m_b="<<m_b<<endl;
    }
    
    //基类C
    class C{ 
    public:
        C(int c);
    public:
        void display();
    protected:
        int m_c;
    };
    C::C(int c): m_c(c){  }
    void C::display(){ 
        cout<<"Class C: m_c="<<m_c<<endl;
    }
    
    //最终派生类D
    class D: public B, public C{ 
    public:
        D(int a, int b, int c, int d);
    public:
        void display();
    private:
        int m_d;
    };
    D::D(int a, int b, int c, int d): B(a, b), C(c), m_d(d){  }
    void D::display(){ 
        cout<<"Class D: m_a="<<m_a<<", m_b="<<m_b<<", m_c="<<m_c<<", m_d="<<m_d<<endl;
    }
    
    
    int main(){ 
        A *pa = new A(1);
        B *pb = new B(2, 20);
        C *pc = new C(3);
        D *pd = new D(4, 40, 400, 4000);
    
        pa = pd;
        pa -> display();
    
        pb = pd;
        pb -> display();
    
        pc = pd;
        pc -> display();
    
        cout<<"-----------------------"<<endl;
        cout<<"pa="<<pa<<endl;
        cout<<"pb="<<pb<<endl;
        cout<<"pc="<<pc<<endl;
        cout<<"pd="<<pd<<endl;
    
        return 0;
    }

运行结果：

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

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

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

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

修改上例中 main() 函数内部的代码，用引用取代指针：

int main(){ 
        D d(4, 40, 400, 4000);
       
        A &ra = d;
        B &rb = d;
        C &rc = d;
       
        ra.display();
        rb.display();
        rc.display();
    
        return 0;
    }

运行结果：

Class A: m_a=4
    Class B: m_a=4, m_b=40
    Class C: m_c=400

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

引用和指针的表现之所以如此类似，是因为引用和指针并没有本质上的区别，引用仅仅是对指针进行了简单封装。

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

[20200314150431224.png]: /images/20230529/4202e52f34964455a53e870d4ae49bc1.png
[20200314150655678.jpg]: /images/20230529/aa9cdf1d08554fa7a2e983591e1e5e02.png