c++中向上轉型(安全)和向下轉型(不安全)

//基本的向上構造

#include <iostream>                                                                                                                                                              
using namespace std;

class A{
    public:
        void myfunc(){
            cout << "A myfunc" << endl;
        }

        virtual void mytest(){
            cout << "A mytest" << endl;
        }
};

class B:public A{
    public:
        void myfunc(){
            cout << "B myfunc" << endl;
        }
        virtual void mytest(){
            cout << "B mytest"  << endl;
        }

};

int main(void){
    A* pa = new A();
    B* pb = new B();
    pa = pb;//向上轉型,隱式的,是安全的(pb = static_cast<B*>(pa)是向下轉型,不安全的.)
    

    pb->myfunc();//B myfunc
    pb->mytest();//B mytest

    pa->myfunc();//A myfunc

    pa->mytest();//B mytest   向上轉型達到,多態(tài)的目的.

    return 0;

}

//向上轉型+虛函數
#include <iostream>
using namespace std;

class Integer{
public:
    Integer(int r):m_r(r){}
    virtual Integer& operator+=(const Integer& that){//虛函數可以為拷貝構造函數.
        m_r +=that.m_r;
        return *this;
    }
    int m_r;
};

class Complex:public Integer{
public:
    Complex(int r,int i):Integer(r),m_i(i){}
    Complex& operator+=(const Integer& c){//這里向上轉型,這樣
    //形參既可以接受Integer也可以接受Complex類型的參數.
        Integer::operator+=(c);
        m_i += ((const Complex&)c).m_i;//這里是重點,c有可能是const Integer&類型的
                                    //所以強制轉換,是可行的.
    }
    int m_i;
};

int main(void){
    Complex c1(1,2),c2(3,4);
    c1 += c2;
    cout << c1.m_r << '+' << c1.m_i << 'i' << endl;
    Integer& i1 = c1; // 4+6i;
    Integer& i2 = c2;//3+4i;
    i1+=i2;//i1調用子類Complex的拷貝賦值函數.
    cout << c1.m_r << '+' << c1.m_i << 'i' << endl;//7+10i;
    return 0;

}