虚函数

#include <iostream>
using namespace std;
class base{         //基类
public:
    void a(void)
    { 
        cout<<"base::a called\n";
    }
    virtual void b(void)   //虚函数
    {
        cout<<"base::b called\n";
    }
    virtual void c(void)   //虚函数
    {
        cout<<"base::c called\n";
    }
};

class derived:public base{     //派生类
public: 
    void a(void) {cout<<"derived::a called\n";}   //派生类自定义的成员函数a 和 b，c继承于基类
    void b(void) {cout<<"derived::b called\n";}
};

void do_base(base &a_base)  //  基类作为变量，只在基类找成员函数
{
cout<<"call function in the base class\n";
a_base.a();  //base::a called\n
a_base.b();  //derived::b called\n  虚函数作用
a_base.c();  //base::c called\n
}

int main()
{
derived a_derived;  //定义derived对象
cout<<"calling function in the derived class\n";

a_derived.a();  //调用a时，查看派生类，derived：：a called
a_derived.b();  //derived::b called\n
a_derived.c();  //base::c called\n  派生类寻找失败，基类寻找 

do_base(a_derived); 
system("pause");
return (0);
}

base为基类  derived为派生类

派生类有三个成员函数，其中两个是自定的：a和b，第三个c是继承于基类的，当调用a时，先查看派生类是否有a的定义：base::a called

b同理得:：base::b called

但是当调用c时，派生类中没有定义这个成员函数，所以转到基类中寻找，即得到：base::c called

do_base函数，带有一个基类作为它的变量，所以C++只在基类中寻找成员函数

将输出：

base::a called
当调用成员函数b时，因为基类中b函数是一个虚函数，C++首先在派生类中寻找有没有成员函数b，然后在基类寻找，所以调用b输出：

derived::b called
当调用成员函数c时，先在派生类中寻找函数，但c并没有在派生类中定义，所以再去基类寻找，所以调用c输出：

base::c called

#include <iostream>
using namespace std;
class animal
{
public:
    void eat()
    {
        cout<<"animal eat"<<endl;
    }
virtual    void breathe()
    {
        cout<<"animal breathe"<<endl;
    }
};
class  fish:public animal
{
public:
    void breathe()
    {
        cout<<"fish breathe"<<endl;
    }
};
void fn(animal * pAn)    //指向animal类的指针作为全局函数fn（）的参数 将基类作为参数，若有虚函数，调用派生类中的函数实现
{
    pAn->breathe();
}
void main()
{              //指针表示一个地址
animal *pAn;    //定义指向animal类的指针 pAn表示地址 *pAn表示该地址的值
fish fh;        //实例化fish对象
pAn=&fh;        //将fh的地址传给pAn  因为fish对象也是animal对象，将fish转换成animal类型不需要强制类型转换，C++编译器会自动转换
fn(pAn);        //执行fn函数  ，如果animal中breathe为虚函数，C++就会采取迟绑定技术
system("pause");
//多态性：在基类的函数前加virtual关键字，在派生类中重写该函数，运行时就会根据对象的实际类型来调用相应函数
}