Effective C++|Chapter 6:继承与面向对象设计

C++各种不同特性的真正意义。例如"public继承"意味着"is-a"，virtual函数意味"接口必须被继承"，non-virtual函数意味"接口和实现必须被继承"。

Item32：确定你的public继承塑模出is-a关系

• 只需要记住：public inheritance（公开继承）意味"is-a"（是一种）的关系。derived class is a base class.

Item33：避免遮掩继承而来的名称

这个题材要讨论和作用域有关的话题

int x;  // global变量
void someFunc()
{
	double x;   // local变量
	std::cin >> x;   // 操作与local变量x
}

---

• 以下述为例，探讨编译器搜索变量的顺序：编译器要估算mf2 refer to what，就要查找各作用域是否存在mf2的声明式。首先查找local作用域（mf4覆盖的作用域），其次查找其外围作用域，即class Derived 覆盖的作用域，再找base class的作用域，再找base的那个namespaces的作用域，最后查找global作用域。

  class Base {
  private:
  	int x;
  public:
  	virtual void mf1() = 0;
  	virtual void mf2();
  	void mf3();
  	...
  }
  class Derived : public Base {
  public:
  	virtual void mf1();
  	void mf4();
  	...
  }
  void Derived::mf4()
  {
  	...
  	mf2();
  }
  

• 重写子类的函数 【不管是virtual函数还是non-virtual函数】 会覆盖掉父类所有重载的同名函数：【这种public继承而又不继承那些重载函数，显然这违反了base和derived classes之间的is-a关系】

  class Base {
  private:
  	int x;
  public:
  	// virtual函数
  	virtual void mf1() = 0;
  	virtual void mf1(int);
  	virtual void mf2();
  	// non-virtual函数
  	void mf3();
  	void mf3(double);
  }
  class Derived: public Base {
  public:
  	// virtual函数
  	virtual void mf1() = 0;
  	// non-virtual函数
  	void mf3();
  }
  

  Derived d;
  int x;
  d.mf1();  // 调用Derived::mf1
  d.mf1(x);  // 错误，Derived::mf1覆盖了Base::mf1
  d.mf2();   // 调用继承的Base::mf2()
  d.mf3();  // 调用Derived::mf3
  d.mf3(x);  // 错误，Derived::mf3覆盖了Base::mf3
  

• 为了不违反base和derived classes之间的is-a关系，C++的derived class重写base class的函数时，需使用using base::func，让base的重载函数在derived class作用域内都可见：

  class Base {
  private:
  	int x;
  public:
  	// virtual函数
  	virtual void mf1() = 0;
  	virtual void mf1(int);
  	virtual void mf2();
  	// non-virtual函数
  	void mf3();
  	void mf3(double);
  }
  class Derived: public Base {
  public:
  	// 让Base class内名为mf1和mf3的所有东西
  	// 在Derived作用域内都可见
  	using Base::mf1;
  	using Base::mf3;
  	// virtual函数
  	virtual void mf1() = 0;
  	// non-virtual函数
  	void mf3();
  }
  

• 请记住：

  • derived classes内的名称会遮掩base classes内的名称。在public继承下从来没有人希望如此；
  • 为了让被掩盖的名称再见天日，可使用using声明式。

Item34：区分接口继承和实现继承

// 纯虚函数的声明使得Shape是个抽象对象，无法对其实例化
class Shape {  
public:
	virtual void draw() const = 0;  // 纯虚函数
	virtual void error(const string& msg); // 虚函数
	int objectID() const;
	...
}
class Rectangle: public Shape {...};
class Ellipse: public Shape {...};

• 声明一个纯虚函数的目的是让derived class只继承函数接口：因为纯虚函数的两个最突出的特性是——①在base类没有定义；②在derived class必须重新声明。【base class的纯虚函数声明式似乎在说：你必须提供一个draw函数，但我不干涉你怎么实现它。】

Shape* ps = new Shape;  // 错误！Shape是抽象的
Shape* ps1 = new Rectangle;  // 可
p1->draw();  // 调用Rectangle的draw
Shape* ps2 = new Ellipse;  // 可
p2->draw();  // 调用Ellipse的draw

• 声明纯虚函数的目的，是让derived calsses继承该函数的接口和缺省（默认）实现。【Shape::error的声明式告诉derived classes的设计者：“你必须支持一个error函数，但如果你不想写一个，可以使用Shape class提供的缺省版本”】

  class Airport { ... }
  class Airplane {
  public:
  	virtual void fly(const Airport& destination);
  	...
  };
  // 虚函数fly()的缺省实现。若ModelA、ModelB没有重写fly()
  void Airplane::fly(const Airport& destination)
  {
  	...
  };
  class ModelA: public Airplane {...};
  class ModelB: public Airplane {...};
  

• 声明non-virtual函数的目的是为了令derived classes继承函数的接口及一份强制性实现。【每个Shape对象都有一个用来产生对象识别码的函数；此识别码总是采用相同计算方法，该方法由Shape::objectID的定义式觉得，任何derived class都不应该尝试改变其行为】

  class Shape {
  public:
  	int objectID() const;
  	...	
  };
  Shape::objectID() {
  	...
  }
  class modelA : public Shape {...}
  class modelB : public Shape {...}
  

• 选择纯虚函数、虚函数、非虚函数前要明确你想要derived classes继承的东西。常犯的错误是：

  • 1）将所有函数声明为non-virtual。这使得derived classes没有余裕空间进行特化工作。
  • 2）将所有成员函数声明为virtual。

• 请记住：

  • 接口继承和实现继承（非虚函数）不同。 在public继承下，derived classes总是继承base class的接口；
  • 纯虚函数只具体指定接口继承；
  • 虚函数具体指定接口继承及缺省实现继承；
  • 非虚函数具体指定接口以及强制性实现继承。

Item37：绝不重新定义继承而来的缺省参数值

• 本Item成立的理由非常直接而明确：virtual函数是动态绑定，而缺省参数是静态绑定。

• 因为静态绑定下这个函数并不从其base继承缺省参数值，因此若客户以对象调用此函数，一定要指定参数值；但若以指针调用此函数，可以不指定参数值，因为动态绑定下这个函数会从其base继承缺省参数值

  class Shape {
  public:
  	enum ShapeColor{Red, Green, Blue};
  	virtual void draw(ShapeColor color = Red) const = 0;
  };
  class Rectangle: public Shape {
  public:
  	// Note：赋予不同的缺省函数，会出问题！
  	virtual void draw(ShapeColor color = Green) const;
  };
  class Circle: public Shape {
  public:
  	// 因为静态绑定下这个函数并不从其base继承缺省参数值，因此若客户以对象调用此函数，一定要指定参数值；
  	// 但若以指针调用此函数，可以不指定参数值，因为动态绑定下这个函数会从其base继承缺省参数值
  	virtual void draw(ShapeColor color) const;
  };
  

  • 动态类型：即本例的Circle、Rectangle；静态类型：即本例的Shape；

  Shape* ps;
  Shape* pc = new Circle;
  Shape* pr = new Rectangle;
  pr->draw();  // 调用Rectangle::draw(Shape::Red)!!
  

• 原因：运行期效率。若缺省参数值是动态绑定，则编译器就必须在运行期为virtual函数决定适当的参数缺省值，比 “在编译器决定” 的机制更慢更复杂。

• 解决办法：使用NVI(non-virtual interface)非虚接口手法：即base class的public 非虚函数调用private虚函数，private虚函数被derived class重写。

  class Shape {
  public:
  	enum ShapeColor{Red, Green, Blue};
  	void draw(ShapeColor color = Red) const 
  	{
  		doDraw(color);
  	}
  private:
  	virtual void doDraw(ShapeColor color) const;
  };
  class Rectangle: public Shape {
  public:
  	... 
  private:
  	virtual void doDraw(ShapeColor color) const { ... };
  };
  

Item40：明智而审慎地使用多重继承

class BorrowableItem {
public:
	void checkOut();
};

class ElectronicGadget {
public:
	void checkOut() const;
};

class MP3Player: public BorrowableItem, public ElectronicGadget {
	...;
}

• 以下示例会产生歧义！【规则：编译器在看到是否有个函数可取用之前，首先会找出对此调用的最佳匹配函数，而后才检验其可用性。】因此，尽管ElectronicGadget::checkOut()是私有的，BorrowableItem::checkOut()是公有的，可取用性唯一，但在寻找最佳匹配函数之前就产生错误，根本未进入可取用行审查阶段。

  MP3Player mp;
  mp.checkOut();  // 歧义！
  
  // 应使用：
  mp.BorrowableItem::checkOut(); 
  

• 避免“钻石型多重继承”：IOFile会从其每一个base class继承一份File里的成员变量（例如fileName）,但这并不必要重复

  class File {...};
  class InputFile: public File { ... };
  class OutputFile: public File { ... };
  class IOFile: public InputFile, public OutputFile { ...};
  

  • 解决办法：virtual 继承 【缺点：由于virtual涉及到动态绑定，因此使用virtual继承的那些class所产生的对象往往比使用non-virtual继承的兄弟体积大】

  class File {...};
  class InputFile: virtual public File { ... };
  class OutputFile: virtual public File { ... };
  class IOFile: public InputFile, public OutputFile { ...};
  

• 请记住

  • 多重继承比单一继承复杂。它可能导致新的歧义性，以及对virtual继承的需要；
  • virtual继承会增加大小、速度、初始化（及赋值）复杂度等等成本。如果virtual base class不带任何数据，将是最具使用价值的情况。