第13周多态性与虚函数程序阅读

/*
 *All rights reserved.
 *文件名称:main.cpp
 *作        者:姜 甜 甜
 *完成日期:2015年6月1日
 *版  本  号:v1.0
 *问题描述：无
 */                                       

#include<iostream>
using namespace std;
class A
{
    int a;
public:
    A():a(5) {}
    virtual void print()const
    {
        cout<<a;
    }
};
class B: public A
{
    char b;
public:
    B()
    {
        b='E';
    }
    void print() const
    {
        cout<<b;
    }
};
void show(A &x)
{
    x.print();
}
int main()
{
    A d1,*p;
    B d2;
    p=&d2;
    d1.print(); //实现A
    d2.print();  //实现B
    p->print();  //通过虚函数调用B
    show(d1);   //实现A
    show(d2);   //形参引用基类部分，但由于虚函数调用B的
    return 0;
}

输出：5EE5E

虚函数抽象意义，在派生类中具体化。

#include <iostream>
using namespace std;
class BASE
{
private:
    char c;
public:
    BASE(char n):c(n) {}
    virtual ~BASE() { cout<<c; }
};
class DERIVED:public BASE
{
private:
    char c;
public:
    DERIVED(char n):BASE(n+1),c(n) {}
    ~DERIVED(){ cout<<c; }
};
int main(){
    DERIVED d('X');
    return 0;
}  

虚析构函数：

如果用new建立派生类对象，并由一个基类的指针变量指向该对象，释放对象时，只执行基类的析构
派生类析构别忽略。所以，要将基类定义虚析构函数，派生类也会自动成为虚函数。

#include <iostream>
using namespace std;
class Base
{
public:
    virtual void Who() =0;//纯虚函数
};
class FirstDerived:public Base
{
public:
    void Who() { cout<<"F"; }
};
class SecondDerived:public Base
{
public:
    void Who() { cout<<"S"; }
};
int main()
{
    FirstDerived first_obj;
    SecondDerived second_obj;
    Base &bref=first_obj;
    bref.Who();//F
    bref=second_obj;   //引用的初始化，获得了值，引用的关系不变，相当于first_obj=second_obj.

    bref.Who();
    Base *bp;
    bp=&first_obj;
    bp->Who();
    bp=&second_obj;
    bp->Who();
    return 0;
}

纯虚函数：？？？？执行虚函数的作用。

思考：

#include <iostream>
using namespace std;
class Vehicle  //交通工具
{
public:
    void run() const
    { cout << "run a vehicle. "<<endl;  }
};
class Car: public Vehicle  //汽车
{
public:
    void run() const
    { cout << "run a car. "<<endl; }
};
class Airplane: public Vehicle  //飞机
{
public:
    void run() const
    { cout << "run a airplane. "<<endl; }
};
int main()
{
    cout<<"(a) 直接用对象访问成员函数: "<<endl;
    Vehicle v;
    v.run();
    Car car;
    Airplane airplane;
    car.run();
    airplane.run();
    cout<<"(b)用指向基类的指针访问成员函数: "<<endl;
    Vehicle *vp;
    vp=&car;
    vp->run();
    vp=&airplane; //指向基类的指针不能访问派生类的对象。
    vp->run();
    return 0;
}

 能够执行派生类的函数。

||=== 生成: Debug in 12 (compiler: GNU GCC Compiler) ===|
C:\Documents and Settings\Administrator\桌面\12\main.cpp||In function 'int main()':|
C:\Documents and Settings\Administrator\桌面\12\main.cpp|22|error: cannot declare variable 'v' to be of abstract type 'Vehicle'|
C:\Documents and Settings\Administrator\桌面\12\main.cpp|3|note:   because the following virtual functions are pure within 'Vehicle':|
C:\Documents and Settings\Administrator\桌面\12\main.cpp|5|note:     virtual void Vehicle::run() const|
||=== Build 失败了: 1 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===|

原是   v.run();    当基类为纯虚函数(抽象函数）不能建立对象。结果：通过指针（指向基类的指针）能调用派生类的函数。