Effective C++ 规则34：区分接口继承和实现继承

这一条款中的精华总结为以下三点：

• 纯虚函数只提供接口继承，但可以被实现；
• 虚函数既提供接口继承，也提供了一份默认实现，即也提供实现继承；
• 普通函数既提供接口继承，也提供实现继承。

上面的结论适用于public继承中的public函数。

一个XYZ航空公司设计飞机继承体系，该公司有A型和B型两种飞机，都以相同方式飞行，可以考虑这样设计继承体系：

    class Airport{ ……};
    class Airplane{
    public:
        virtual void fly(const Airport& destation);
        ……
    };
    void Airplane::fly(const Airport& destation)
    {
        //将飞机飞到指定的destination
    }
    class ModelA: public Airplane{……};
    class ModelB: public Airplane{……};

        因为不同型飞机不需要不同的fly实现，Airplane::fly被声明为virtual；为了避免在ModelA和ModelB重新撰写相同代码，缺省的飞行行为有Airplane::fly提供。
        上面这种设计方式是典型的面向对象设计。两个classes共享的性质放到base class中，然后被这两个class继承。这样可以突出共同性质，避免代码重复。
        但是如果XYZ要购买一种新型飞机C，C和A、B飞行方式不同。XYZ公司程序员给C型飞机添加了一个class,但是没有重新定义fly函数。

class ModelC: public Airplane{……};

        然后又写了如下代码 ：

    Airport PDX()；//某个机场
    Airplane* pa=new ModelC;
    ……
    pa->fly(PDX);//调用了Airplane::fly

        这会造成大灾难，因为程序员试图以ModelA或ModelB的方式来飞ModelC。问题不在于Airplane::fly有缺省行为，在于ModelC在未搞清楚的情况下就使用了这个缺省行为。幸运的是可以做到：提供缺省实现给derived classes，但是除非derived classes真的要用。

    class Airplane{
    public:
        virtual void fly(const Airport& destation)=0;
    protected:
        void defaultFly(const Airport& destation);
    };
    void Airplane::deFaultFly(const Airport& destation)
    {
        //将飞机飞到指定目的地
    }

        这里将Airplane::fly改为pure virtual函数，只提供接口。但是缺省的行为在Airplane::defaultFly函数中出现。如果要使用其缺省行为，可以在fly函数调用defaultFly函数。

    class ModelA: public Airplane{
    public:
        virtual void fly(const Airport& destation)
        { defaultFly(destation)}
    };
    class ModelB: public Airplane
    ……

    class ModelC: public Airplane{
    public:
        virtual void fly(const Airport& destination);
    };
    void ModelC:fly(const Airport& destination)
    {
        //将C型飞机飞到指定目的地
    }

        上面设计中，Airplane::defaultFly是个non-virtual，derived classes不用重新定义。

        有的人返回以不同的函数分别将提供接口和缺省实现，这样会因为过度雷同的函数名称引起class命名空间污染问题；但是他们同意接口和缺省实现应该分开。我们可以利用“pure virtual函数必须在derived classes中重新声明，但它们可以拥有自己的实现”这个特点。

    class Airplane{
    public:
        virtual void fly(const Airport& destination)=0;
        ……
    };
    void Airplane::fly(const Airport& destination)//pure virtual函数实现
    {
        //缺省实现
    }


    class ModelA: public Airplane{
    public: 
        virtual void fly(const Airport& destination)
        {Airplane::fly(destination);}
        ……
    };
    class ModelB:public Airplane
    ……

    class ModelC: public Airplane
    {
    public:
        virtual void fly(const Airport& destination);
        ……
    };
    void ModelC::fly(const Airport& destination)
    {
        //ModelC的实现
    }

        这个实现和上一个不同之处在于，用pure virtual函数Airplane::fly替换了独立函数Airplane::defaultFly。现在的fly被分割为两个基本要素：其声明部分表现为接口（derived classes必须使用），定义部分表现为缺省行为（derived classes明确提出申请才可以用）。