多态

 

#include  < iostream.h >

class  A
... {
public:
    A()...{}
    ~A()...{}

    void TestA()
    ...{
        cout<<"Test A"<<endl;
    }

    virtual func()
    ...{
        cout<<"A"<<endl;
    }
} ;

class  B: public  A
... {
public:
    B()...{}
    ~B()...{}

    void TestB()
    ...{
        cout<<"Test B"<<endl;
    }

    func()
    ...{
        cout<<"B"<<endl;
    }
} ;

class  C: public  A
... {
public:
    C()...{}
    ~C()...{}

    void TestC()
    ...{
        cout<<"Test C"<<endl;
    }

    func()
    ...{
        cout<<"C"<<endl;
    }
} ;

void  InvokeFunc(A *  _ptr)
... {
    _ptr->func();
}  

int  main()
... {
    A* ptrA = new A();
    A* ptrB = new B();
    A* ptrC = new C();

       // B* ptrBTemp = new B();

       // InvokeFunc(ptrBTemp);

    InvokeFunc(ptrA);       // 'A'
    InvokeFunc(ptrB);       // 'B'
    InvokeFunc(ptrC);      // 'C'
    
    return 0;
}

 

代码中ptrA, ptrB, ptrC都是指向A的指针，但在调用func()函数时，却是分别调用的A, B, C类的方法。

InvokeFunc(A* _ptr)向调用者展现的都是统一的接口：接受指向A类型的参数作为指针。但是如果声明B* ptrB=new B(), C* ptrC=new C()。同样是可以传递给这个方法作为参数的，也可以实现调用各自的Func方法。

那么使用A* ptrA = new B()和使用B* ptrB = new B()除了前者只能调用A的成员方法和B中所重写的A中的虚方法，后者既能调用A中的方法也能调用B中的方法这样的区别外，还有什么样的区别呢？

在开发中能带给我们其他什么实际的好处呢？

 

Answer:

这种用法可以带来运行期决策。
比如，可以有个基类数组，或链表
A* as[10];

因为有些A*其实是B*，所以调用时可以用B的虚函数。

这种用法只有在A有虚函数的情况下才有用。本来多态的关键也就是虚函数。