条款 34：区分接口继承和实现继承(一)

《Effective C++ 中文版第三版》读书笔记

身为 class 设计者，有时候你希望 derived class 只继承成员函数的接口（也就是声明）：有时候你又希望 derived class 同时继承函数的接口和实现，但又希望能够覆写（override）它们所继承的实现：又有时候你希望 derived class 同时继承函数的接口与实现，并且不允许覆写任何东西。

让我们考虑一个展现绘图程序中各种几何形状的 class 继承体系：

class Shape { 
public: 
    virtual void draw() const = 0; 
    virtual void error(const std::string& msg); 
    int objectID() const; 
}; 

class Rectangle : public Shape {...}; 
class Ellipse : public Shape {...};

Shape 的 pure virtual 函数 draw 使它成为一个抽象 class。Shape 强烈影响了所有以 public 形式继承它的 derived classes。因为：

成员函数的接口总是会被继承。

首先考虑 pure virtual 函数 draw：pure virtual 函数有两个最突出的特性：它们必须被任何 “继承了它们” 的具象 class 重新声明，而且它们在抽象 class 中通常没有定义。所以：

声明一个 pure virtual 函数的目的是为了让 derived class 只继承函数接口。Shape::draw 的声明式乃是对具象 derived class 设计者说 “你必须提供一个 draw 函数，但我不干涉你怎么实现它”

令人意外的是，我们竟然可以为 pure virtual 函数提供定义。但调用它的唯一途径是 “调用时明确指出其 class 名称”：

Shape* ps = new Shape; // wrong! abstract class Shape 
Shape* ps1 = new Rectangle; 
ps1->draw(); // Rectangle::draw() 
Shape* ps2 = new Ellipse; 
ps2->draw(); // Ellipse::draw() 
ps1->Shape::draw(); 
ps2->Shape::draw();

它可以提供一种机制，为简朴 impure virtual 函数提更平常更安全的缺省实现。

impure virtual 函数会提供一份实现代码，derived classes 可能覆写（override）它：

生命简朴的（非纯）impure virtual 函数的目的，是让 derived class 继承该函数的接口和缺省实现。

考虑 Shape::error 这个例子。

其接口表示，每个 class 都必须支持一个 “当遇上错误时可调用” 的函数，但每个 class 可自由处理错误。如果某个 class 不想针对错误作出任何特殊行为，可以退回到 Shape class 提供的缺省错误处理行为。

但是允许 impure virtual 函数同时指定函数声明和函数缺省行为，却有可能造成危险。考虑 xyz 航空公司设计的继承体系。该公司只有 A 和 B 两种飞机，相同方式飞行：

class Airport {...}; 

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

void Airplane::fly(const Airport& destination) 
{ 
    //缺省代码，将飞机飞至指定目的地 
} 

class ModelA: public Airplane {...}; 

class ModelB: public Airplane {...};

为表示所有飞机都一定能飞，并阐明 “不同型飞机原则上需要不同的 fly 实现” Airplane::fly 被声明为 virtual。然而为了避免在 ModelA 和 ModelB 中撰写相同代码，缺省飞行行为有 Airplane::fly 提供，它同时被 ModelA 和 ModelB 继承。

现在，xyz 决定购买一种新式 C 型飞机，这种飞机的飞行方式不同。

xyz 的程序员在继承体系中对 C 型飞机添加了一个 class，但由于他们急着让新飞机上线服务，忘了重新定义器 fly 函数：

class ModelC: public Airplane {...};

然后在代码中有一些诸如此类的动作：

Airport PDX(...); 
Airplane* pa = new ModelC; 
... 
pa->fly(PDX);

这将酿成大灾难：这个程序试图用 ModelA 和 ModelB 的飞行方式来飞 ModelC。

问题不在 Airplane::fly() 有缺省行为，而在于 ModelC 在未明白说出 “我要” 的情况下就继承了该缺省行为。我们可以做到 “提供缺省实现给 derived classes，但除非它们明确要求，否则免谈”。此间伎俩在于切断 “virtual 函数接口” 和其 “缺省实现” 之间的连接。下面是一种做法：

class Airplane { 

public: 
    virtual void fly(const Airport& destination) = 0; 
    ... 

protected: 
    void defaultFly(const Airport& destination); 
}; 

void Airplane::defaultFly(const Airport& destination) 
{ 
    //缺省行为，将飞机飞至目的地 
}

fly 已被改成为一个 pure virtual 函数，只提供飞行接口。缺省行为以 defaultFly 出现在 Airplane class 中。若想使用缺省实现（例如 ModelA 和 ModelB），可以在 fly 中对 defaultFly 做一个 inline 调用：

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

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

现在 ModelC 不可能意外继承不正确的 fly 实现代码了，因为 Airplane 中的 pure virtual 函数迫使 ModelC 必须提供自己的 fly 版本：

class ModelC: public Airplane { 
public: 
    virtual void fly(const Airport& destination); 
    ... 
}; 

void ModelC::fly(const Airport& destination) 
{ 
    //将C型飞机飞至指定的目的地 
}

这个方案并非安全无虞，程序员还是可能因为剪贴（copy-and-paste）代码而招来麻烦，但它比原来的设计值得依赖。

Airplane::defaultFly 是一个 non-virtual 函数，这一点也很重要。因为没有任何一个 derived class 应该重新定义此函数。

有些人反对以不同的函数分别提供接口和缺省实现，向上述的 fly 和 defaultFly 那样。我们可以利用 “pure virtual 函数必须在 derived class 中重新声明，但它们可以拥有自己的实现” 这一事实。下面是 Airplane 继承体系如何给 pure virtual 函数一份定义：

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 { 
public: 
    virtual void fly(const Airport& destination) 
    { 
        Airplane::fly(destination); 
    } 
    ... 
}; 

class ModelC: public Airplane { 
public: 
    virtual void fly(const Airport& destination) 
    ... 
}; 

void ModelC::fly(const Airport& destination) 
{ 
    // 将 C 型飞机飞至指定目的地 
}

身为 class 设计者，有时候你希望 derived class 只继承成员函数的接口（也就是声明）：有时候你又希望 derived class 同时继承函数的
接口和实现，但又希望能够覆写（override）它们所继承的实现：又有时候你希望 derived class 同时继承函数的接口与实现，并且不允许覆写任何东西。
让我们考虑一个展现绘图程序中各种几何形状的 class 继承体系：

class Shape { 
public: 
    virtual void draw() const = 0; 
    virtual void error(const std::string& msg); 
    int objectID() const; 
}; 
class Rectangle : public Shape {...}; 
class Ellipse : public Shape {...};

Shape 的 pure virtual 函数 draw 使它成为一个抽象 class。Shape 强烈影响了所有以 public 形式继承它的 derived classes。因为：成员函数的接口总是会被继承。

首先考虑 pure virtual 函数 draw：pure virtual 函数有两个最突出的特性：它们必须被任何 “继承了它们” 的具象 class 重新声明，而且它们在抽象 class 中通常没有定义。所以：声明一个 pure virtual 函数的目的是为了让 derived class 只继承函数接口。

Shape::draw 的声明式乃是对具象 derived class 设计者说 “你必须提供一个 draw 函数，但我不干涉你怎么实现它”

令人意外的是，我们竟然可以为 pure virtual 函数提供定义。但调用它的唯一途径是 “调用时明确指出其 class 名称”：

Shape* ps = new Shape; //wrong! abstract class Shape 
Shape* ps1 = new Rectangle; 
ps1->draw(); //Rectangle::draw() 
Shape* ps2 = new Ellipse; 
ps2->draw(); //Ellipse::draw() 
ps1->Shape::draw(); 
ps2->Shape::draw();

它可以提供一种机制，为简朴 impure virtual 函数提更平常更安全的缺省实现。
impure virtual 函数会提供一份实现代码，derived classes 可能覆写（override）它：
生命简朴的（非纯）impure virtual 函数的目的，是让 derived class 继承该函数的接口和缺省实现。