c++: C++虚函数和纯虚函数

1. 纯虚函数

1.1 定义

纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类(继承类)都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加=0。
定义纯虚函数的目的在于，使派生类仅仅只是继承函数的接口。

1.2 格式

virtual <函数返回类型> 函数名 (参数表) = 0;

1.3 例子

//基类Base
class Base
{
    public:
        //普通函数
        void f1(int x)
        { 
                cout << "\nBase::f1(int) " << x << endl;
        } 
        //虚函数
        virtual void f2(int x)
        {
                cout << "Base::f2(int)"<< x << endl;
        } 
        //纯虚函数，将由子类实现
        virtual void f3(int x)=0;
};

2. 虚函素

2.1 定义

在某基类中声明为 virtual 并在一个或多个派生类中被重新定义的成员函数

2.2 格式

virtual <函数返回类型> 函数名 (参数表)
{
    函数体;
};

实现多态性，通过指向派生类的基类指针或引用，访问派生类中同名覆盖成员函数

2.3 例子

class A
{
public:
        //虚函数
        virtual void f2(int x)
        {
                cout << "Base::f2(int)"<< x << endl;
        } 
};

3.混合例子：

3.1 基类

#include <iostream>
using namespace std;
//基类Base
class Base
{
    public:
        //普通函数
        void f1(int x)
        { 
                cout << "Base::f1(int) " << x << endl;
        } 
        //虚函数
        virtual void f2(int x)
        {
                cout << "Base::f2(void)"<< x << endl;
        } 
        //纯虚函数，将由子类实现
        virtual void f3(int x)=0;

};

3.2 派生类

//继承Derived
class Derived:public Base
{
    public:
        void f1(int x)
        {
                cout<<"\nDerived:g1(int)"<< x << endl;
        }
        //覆盖Base的f2
        void f2(int x)
        {
                cout<<"Derived:g2(int)"<< x << endl;
        }
        //在子类中被重载，以多态的形式被调用，实现Base的纯虚函数
        //a.编译时多态性：通过重载函数实现
        //b 运行时多态性：通过虚函数实现。
        void f3(int x)
        {
                cout<<"Derived:g3(int)"<< x << endl;
        }
};

3.3 主函数

int main(int argc, char **argv)
{
       Derived *pderived = new Derived;
       pderived->f1(1);
       pderived->f2(2);
       pderived->f3(3);


       Base *pbase = new Derived; 
       pbase->f1(1);
       pbase->f2(2);
       pbase->f3(3); 

       Derived derived;
       derived.f1(1);
       derived.f2(2);
       derived.f3(3);

       //Base base; //有纯虚函数不能声明
       //Base *base = new base; //有纯虚函数不能new
       //base.f1(1);
       //base.f2(2);
       //base.f3(3);       
}