//基本的向上构造

#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   向上转型达到,多态的目的.

    return 0;

}

//向上转型+虚函数#include 
     
      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;}