EC++学习笔记(六) 继承和面向对象设计

条款32:确定你的 public 继承塑模出 is-a 关系

public inheritance 意味着 is-a 关系
class Derived 以 public 形式继承 class Base, 则每一个 Derived对象同时也是一个 Base对象，反之不成立
可以施行于Base class 对象身上的每件事情，也同样可以施行于Derived class 对象

class Person{...};

class Student : public Person{...};

 

每一个Student都是Person，反之，每个Person不一定是Student
正因为具有 is-a 关系，指向Base类型的引用可以引用Base类型对象，也可以引用Derived类型对象(多态基础)

 

条款33:通过组合塑模出 has-a 关系

 

class Address{...};

class PhoneNumber{...};

class Person{

public:

    ...

private:

    std::string         name;

    Address             address;

    PhoneNumber         phoneNumber;

};

string对象、Address对象、PhoneNumber对象组合塑模出Person对象
Person class 示范 has-a 关系:每一个Person都 has-a string name、has-a Address、 has-a PhoneNumber

 

条款34:避免遮掩继承而来的名称

内层作用域的名称会遮蔽外围作用域的名称

int x;            //global变量

void func() {

    double x;    //local变量

}

 

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();

};

 

如果 Derived 中mf4实现如下:

void Derived::mf4() {

    mf2();

    ...

}

名称查找规则(作用域由小到大): Derived mf4 ==> class Derived ==> class Base ==> namespace ==> global

 

class Base {

private:

    int x;

public:

    virtual void mf1() = 0;

    virtual void mf1(int);

    virtual void mf2();

    void mf3();

    void mf3(double);

};



class Derived ：public Base {

public:

    virtual void mf1();

    void mf3();

    void mf4();

};

 

class Base 中 mf1() 和 mf3() 被 Derived 中 mf1() 和 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

 

如果继承 class Base 并加上重载函数，又希望重新定义其中一部分，那么必须为那些原本会被遮蔽的每个名称都引入一个 using 声明，强制声明作用域

class Base {

private:

    int x;

public:

    virtual void mf1() = 0;

    virtual void mf1(int);

    virtual void mf2();

    virtual void mf3();

    virtual void mf3(double);

};



class Derived : public Base{

public:

    using Base::mf1;

    using Base::mf2;

    virtual void mf1();

    void mf3();

    void mf4();

};

 

Derived d;

int x;

d.mf1();    //没问题，调用 Derived::mf1

d.mf1(x);     //没问题，调用 Base::mf1

d.mf2();    //没问题，调用 Base::mf2

d.mf3();    //没问题，调用 Derived::mf3

d.mf3(x);    //没问题，调用 Base::mf3

 

为了让被 base class 遮蔽的名称重见天日，可使用 using 声明式

 

条款35:区分接口继承和实现继承

class Shape {

public:

    virtual void draw() const = 0;

    virtual void error(const std::string& msg);

    int objectID() const;

};

class Rectangle : public Shape {...};

class Elllipse  : public Shape {...};

 

成员函数的接口总是被继承，因为 public 继承意味着 is-a，所以对base class 为真的任何事情一定也对其 derived class 为真

1.pure virtual member function:

pure virtual 函数有两个最突出的特性：

a.必须被任何"继承了它们"的 class 重新声明

b.它们在 抽象基类里面通常没有定义

 

声明一个 pure virtual 函数是为了让 derived class 只继承 函数接口

 

Shape* ps = new Shape;        //错误！抽象基类不能实例化

Shape* ps1 = new Rectangle;    //基类指针指向派生类对象

ps1->draw();                //多态:调用 Rectangle::draw



Shape* ps2 = new Elllipse;    //基类指针指向派生类对象

ps2->draw();                //多态:调用 Elllipse::draw



ps1->Shape::draw();            //调用 Shape::draw

ps2->Shape::draw();            //调用 Shape::draw

 

2.简朴的 non-pure virtual member function:

声明简朴的 non-pure virtual 函数是为了让 derived class 继承 函数接口 和 函数缺省实现

 

a.函数为 virtual 函数，表明 继承base class 的函数接口
b.函数为 non-pure 函数，表明 base class 可以为该函数提供一个缺省实现，并且让 derived class 继承该函数缺省实现
Shape::error 声明式(non-pure virtual function)是告诉 derived class 的设计者"你必须提供一个 error 函数，但如果你不想自己写一个，可以使用

Shape class 提供的缺省版本"
基类中的所有 non-pure virtual 函数都必须提供一个 缺省实现(可以为空函数体)，否则编译错误

3. non-virtual member function:

声明 non-virtual 函数是为了让 derived class 继承 函数接口 和 函数强制性实现(注意区别于 函数缺省实现)

 

实际上 non-virtual 函数表现出 不变性(所有 derived class 都不能重定义该函数，并且都共享 base class 的同一份强制性函数实现)

 

总结:

设计一个 class 的API函数原型时，必须谨慎选择:

(1)pure virtual member function 继承base class函数接口(derived class 必须重定义该函数)

(2)non-pure virtual member function 继承base class函数接口和函数缺省实现(derived class 没有重定义该函数时，会执行继承而来的缺省实现)

(3)non-virtual member function 继承base class函数接口和函数强制性实现(derived class 不能重定义该函数，都共享继承而来的强制性实现)

 

条款36:考虑 virtual 函数以外的其他选择

设计某个方法时，可以考虑 virtual 函数以外的选择方案，这里主要采用 std::function 结合 std::bind 替换 virtual 函数

 

条款37:绝不重定义继承而来的 non-virtual 函数

条款38:绝不重定义继承而来的 缺省参数值

class Base {

public:

    virtual void func() const = 0;

};



class Derived : public Base {

public:

    virtual void func() const;

};

Base* pBase = new Base;

Base* pDerived = new Derived;

 

(1)对象的静态类型:对象在程序中被声明时所采用的类型
pBase声明为 Base*，所以 pBase 静态类型为 Base*(不论真正指向的对象类型)
pDerived声明为 Base*，所以 pDerived 静态类型为 Base*(不论真正指向的对象类型)

(2)对象的动态类型:目前真正所指对象的类型
pBase真正指向的对象类型为 Base*，所以 pBase 动态类型为 Base*
pDerived真正指向的对象类型为 Derived*，所以 pDerived 动态类型为 Derived*

virtual 函数系动态绑定而来，最终调用哪一份函数实现代码，取决于发出调用的那个对象的动态类型

virtual 函数是动态绑定, 缺省参数值是静态绑定，重定义缺省参数值会导致致命的语义错误.

 

条款39:尽量慎用 private 继承(采用组合)

Base class 里的所有成员通过 private 继承之后, 在 Derived class 中都会变成 private 属性

条款40:禁用 多重继承 和 virtual 继承

采用组合的替代方案, 多重继承和 virtual 继承会导致语义歧义和非常大的复杂度

注:Google c++ 编程规范:所有继承都必须是 public，否则采用组合