C++向上转型

/* C++ 向上/向下转型 */
/* 将派生类赋值给基类(安全) */
//向上转型后通过基类的对象、指针、引用只能访问从基类继承过去的成员（包括成员变量和成员函数），不能访问派生类新增的成员

#include <iostream>
using namespace std;

namespace LL
{
    //基类
    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;
    }
    //派生类B
    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;
    }
}

//基类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()
{
    //1、类型自动转换
    int a0 = 10.9;
    printf("%d\n", a0); //编译器会将小数部分直接丢掉（不是四舍五入）

    float b0 = 10;
    printf("%f\n", b0); //编译器会自动添加小数部分。

    //2、将派生类对象赋值给基类对象(向上转型)
    //包括将派生类对象赋值给基类对象、将派生类指针赋值给基类指针、将派生类引用赋值给基类引用
    //向上转型非常安全，可以由编译器自动完成；向下转型有风险，需要程序员手动干预
    LL::A a(10);
    LL::B b(66, 99);
    //赋值前 赋值的本质 是向内存填充数据
    a.display();
    b.display();
    cout << "--------------" << endl;
    //赋值后
    a = b;
    a.display();
    b.display();

    //3、将派生类对象指针赋值给基类对象指针
    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;       //指向基类A
    pa->display(); //调用基类A的display()
    pb = pd;       //指向基类B
    pb->display();
    pc = pd; //指向基类C
    pc->display();
    cout << "-----------------------" << endl;
    cout << "pa=" << pa << endl; //pa, pb, pd都指向对象内存头部(基类成员) pc指向基类C的头部成员地址(实际上是A基类头部偏移(A + B)的成员变量尺寸)
    cout << "pb=" << pb << endl;
    cout << "pc=" << pc << endl;
    cout << "pd=" << pd << endl;
    /* 编译器通过指针来访问成员变量，指针指向哪个对象就使用哪个对象的数据；编译器通过指针的类型来访问成员函数，指针属于哪个类的类型就使用哪个类的函数。 */

    //4、将派生类引用赋值给基类引用
    D d(4, 40, 400, 4000);

    A &ra = d; //指向基类A
    B &rb = d;
    C &rc = d;

    ra.display(); //调用基类A的display()
    rb.display();
    rc.display();

    return 0;
}