【读书笔记】Effective C++（06）继承与面向对象

时间  2019-12-07
标签 读书笔记 effective c++ 继承 面向对象 栏目 C&C++ 繁體版
原文   原文链接

做者：LogMsegmentfault

本文原载于 https://segmentfault.com/u/logm/articles，不容许转载~函数

6. 继承与面向对象

  • 6.1 条款32：肯定你的public继承是is-a关系

    • public继承的子类对象须要保证能够被视做父类对象来调用函数。
    • class Person {...};
class Student : public Person {...};

void eat(const Person& p);
void study(const Student& s);
eat(p);   // ok
eat(s);   // ok，Student能够视做Person调用函数
study(s);   //ok
study(p);   //error，Person不能视做Student

  • 6.2 条款33：避免遮掩继承而来的名称

    • int x;  //global变量
void someFunc() {
    double x;  //local变量
    std::cin >> x;  //local变量的x遮掩了global变量的x，实际起做用的是local变量的x
}
    • //定义基类
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();
    ...
};

//使用
Derived d;
int x;
...
d.mf1();    //ok，调用Derived::mf1
d.mf1(x);   //bad，由于Derived::mf1遮掩了Base::mf1
d.mf2();    //ok，调用Base::mf2
d.mf3();    //ok，调用Derived::mf3
d.mf3(x);   //bad，由于Derived::mf3遮掩了Base::mf3
    • //解决方法1
//定义派生类
class Derived : public Base {
public:
    using Base::mf1;    //让基类中名为mf1和mf3的全部东西在此做用域内可见
    using Base::mf3;
    virtual void mf1();
    void mf3();
    void mf4();
    ...
};

//使用
Derived d;
int x;
...
d.mf1();    //ok，调用Derived::mf1
d.mf1(x);   //ok，调用Base::mf1
d.mf2();    //ok，调用Base::mf2
d.mf3();    //ok，调用Derived::mf3
d.mf3(x);   //ok，调用Base::mf3
    • //解决方法2
//定义基类
class Base {
public:
    virtual void mf1() = 0;
    virtual void mf1(int);
    ...
};
//定义派生类
class Derived : public Base {
public:
    virtual void mf1() { Base::mf1(); }  // 转交函数
    ...
};

//使用
Derived d;
int x;
...
d.mf1();    //ok，调用Derived::mf1
d.mf1(x);   //bad，由于Base::mf1被遮掩，且Base::mf1(int)没有被转交

  • 6.3 条款34：区分接口继承和实现继承

    • 以下代码所示，有3类继承关系：this

      • 纯虚函数的继承，目的是让派生类只继承函数接口。派生类必须实现该接口。
      • 非纯虚函数的继承，目的是让派生类继承函数接口和缺省实现。派生类能够实现该接口，也能够选择使用基类的缺省实现。
      • 非虚函数的继承，目的是让派生类继承函数接口和强制实现。派生类不该该另外实现该接口，不然发生上一个条款所述的遮掩行为。
    • 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 {...};

  • 6.4 条款35：考虑virtual函数以外的其余选择

    • //假设你正在写一个游戏软件，每一个游戏人物都应该有"健康"这个属性
class GameCharacter {
public:
    virtual int healthValue() const;  //返回游戏人物的健康状态
    ...
};

    • 上面的写法没有问题，基类提供了接口和一个缺省的实现，派生类能够选择是否重写这个函数。可是，做者也提醒，还有一些其它的写法：设计

      • //方法1：借由Non-Virtual Interface（NVI）手法实现Template Method模式
class GameCharacter {
public:
    int healthValue() const {
        ... //在开始主函数前，能够作一些额外的工做
        int retVal = doHealthValue();   //这个函数能够被子函数重写
        ... //在结束主函数后，能够作一些额外的工做
        return retVal;
    }
    ...
private:
    virtual int doHealthValue() const {
        ...
    }
};
      • //方法2：借由函数指针实现Strategy模式
//这种方法容许同一个派生类的不一样对象使用不一样的函数计算健康状态
class GameCharacter {
public:
    typedef int (*HealthCalcFunc)(const GameCharacter&);
    explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc)
      : healthFunc(hcf) {

    }
    int healthValue const {
        return healthFunc(*this);
    }
    ...
private:
    HealthCalcFunc healthFunc;
};
      • //方法3：借由tr1::function完成Strategy模式
//这种方法比函数指针更自由，它能够是函数指针，也能够是任何能够被调用的东西
class GameCharacter {
public:
    typedef std::tr1::function<int (const GameCharacter&)> HealthCalcFunc;
    explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc)
      : healthFunc(hcf) {

    }
    int healthValue const {
        return healthFunc(*this);
    }
    ...
private:
    HealthCalcFunc healthFunc;
}
      • //方法4：古典的Strategy模式
//HealthCalcFunc来自另外一个继承体系
class GameCharacter;
class HealthCalcFunc {
public:
    ...
    virtual int calc(const GameCharacter& gc) const {...}
    ...
};
HealthCalcFunc defaultHealthCalc;

class GameCharacter {
public:
    explicit GameCharacter(HealthCalcFun* phcf = &defaultHealthCalc)
        : pHealthCalc(phcf) {

    }
    int healthValue() const {
        return pHealthCalc->calc(*this);
    }
    ...
private:
    HealthCalcFunc* pHealthCalc;
};

  • 6.5 条款36：毫不从新定义继承而来的non-virtual函数

    • 我怀疑做者这条讲重复了，条款33讲"遮掩"的时候就讲到了这个内容
    • //基类
class B {
public:
    void mf();
    ...
};
//派生类
class D {
public:
    void mf();   //遮掩B::mf
    ...
};
//使用
D x;
B* pB = &d;   //调用B::mf()
pB->mf();
D* pD = &d;   //调用D::mf()
pD->mf();
//若是B::mf()是virtual函数，则上面两处都是调用D::mf()
//因此也就能够解释，条款7所述的"使用多态时，基类的析构必须为virtual"

  • 6.6 条款37：毫不从新定义继承而来的缺省参数值

    • 条款36说了non-virtual不要从新定义，因此在派生类中能从新定义的是virtual函数。
    • virtual函数是动态绑定，而缺省参数值是静态绑定，这就会带来问题。
    • //基类
class Shape {
public:
     enum ShapeColor {Red, Green, Blue};
     virtual void draw(ShapeColor color=Red) const = 0;
};
//派生类
class Rectangle : public Shape {
public:
    virtual void draw(ShapeColor color=Green) const;
    ...
};
//使用
Shape* pR = new Rectangle;  //请注意类型是Shape*
pR->draw();   //调用Rectangle::draw(Shape::Red)，由于缺省值是在编译期间静态绑定的，而pR的静态类型为Shape*，是基类
    • 解决方法是在条款35中找一种替代设计，好比NVI。
    • //基类
class Shape {
public:
    enum ShapeColor {Red, Green, Blue};
    void draw(ShapeColor color=Red) const {
        doDraw(color);
    }
    ...
private:
    virtual void doDraw(ShapeColor color) const = 0;
};
//派生类
class Rectangle : public Shape {
public:
    ...
private:
    virtual void doDraw(ShapeColor color) const {
        ...
    }
    ...
};

  • 6.7 条款38：确保"复合"是has-a或is-implemented-in-terms-of关系

    • 复合（composition）是类之间的一种关系，不一样于public继承，它表明has-a或"根据某物实现出"这样一种关系。
    • class Address {...};
class PhoneNumber {...};
class Person {
public:
    ...
private:
    std::string name;
    Address address;
    PhoneNumber voiceNumber;
    PhoneNumber faxNumber;
};

  • 6.8 条款39：明智而审慎地使用private继承

    • private继承会将基类中继承而来的全部成员变为private成员。
    • 以下代码所示，private继承的关系更像是"复合"（Student类中带有Person类的一些功能），只有软件实现层面的意义，不具备设计层面上的意义。尽量使用"复合"替代private继承。
    • class Person {...};
class Student : private Person {...};
void eat(const Person& p);

Person p;
Student s;
eat(p);   //ok
eat(s);   //bad，Student不能被视为Person

  • 6.9 条款40：明智而审慎地使用多重继承

    • 多重继承会发生"成员函数或成员变量重名"、"钻石型继承"等问题，对于这种状况建议使用virtual public继承，但这会带来空间和效率的损失。
    • 多重继承的复杂性，致使通常不会使用。只有virtual base classes（也就是继承多个接口）才最有实用价值，它不必定须要virtual public继承。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程