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

public继承意味着is-a。适用于base class身上的每一个函数也一定适用于derived class。

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

几层作用域:

global作用域
- namespace作用域
  - Base class作用域
    - Drive class作用域
      - 成员函数
        
        控制块作用域

当前作用域会遮掩上一层作用域的名称（重载的函数也会直接遮掩）

class Base{

public:

    void f1();

}

class Drive : public Base {

public:

    void f1(int);  //会遮掩f1()，子类并没有继承f1()

}

Drive d;

d.f1();  //错误

d.f1(3); //正确

可以通过using声明式（public继承）或者inline转交（public和private继承）解决这一问题

class Base{

public:

    void f1();

}

//using 声明式

class Drive：public Base {

public:

    using Base::f1;

    void f1(int);

}

//inline转交

class Drive : private Base {

public:

    void f1(){

        Base::f1();

    }

    void f1(int);

}

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

纯虚函数（只提供接口）
- 纯虚函数造成了抽象类，抽象类不可以构造实体（对象）
- Drived class中必须给出纯虚函数的实现
- 纯虚函数可以给出实现（类外）
虚函数（提供接口和缺省实现）
- 用于实现多态
非虚函数（提供了强制实现）
- 可以看成此类独有，且最好不要在Drived class重新定义非虚函数

条款35：考虑virtual函数以外的其他选择

virtual的替代方案

non-virtual interface（NVI）手法，以public non-virtual成员函数包裹较低访问性（privat或protected）的virtual函数

#include <iostream>

#include <string>

#include <memory>

using namespace std;

class base {

public:

    void show() {

        doshow();

    }

private:

    virtual void doshow() const {

        cout << "base" << endl;

    }

};

class drive : public base {

public:

private:

    virtual void doshow() const {

        cout << "drive" << endl;

    }

};

int main() {

   shared_ptr<base> d = shared_ptr<base>(new drive);

   d->show();

}

以函数指针变量替换virtual函数

#include <iostream>

#include <string>

#include <memory>

using namespace std;

class base {

    typedef void (*showFuc) (const base&);

public:

    explicit base(showFuc _s) : s(_s){}

    void doshow() const {

        cout << "base" << endl;

    }

    int show() const {

        s(*this);

    }

private:

    showFuc s;

};

void showFuc1(const base& b) {

    cout << "function 1: ";

    b.doshow();

}

void showFuc2(const base& b) {

    cout << "function 2: ";

    b.doshow();

}

int main() {

    shared_ptr<base> b1 = shared_ptr<base>(new base(showFuc1));

    shared_ptr<base> b2 = shared_ptr<base>(new base(showFuc2));

    b1->show();

    b2->show();

}

利用std::function成员变量替换virtual函数（可将函数写在类中）

#include <iostream>

#include <string>

#include <memory>

using namespace std;

class base1 {

public:

    explicit base1(function<void(const base1&)> _f) : f(_f){}

    void doshow() const {

        cout << "base1" << endl;

    }

    void show() const {

        f(*this);

    }

private:

    function<void(const base1&)> f;

};

class base2 {

public:

    void baseFuc(const base1& b) {

        b.doshow();

    }

};

int main() {

    shared_ptr<base2> b2;

    shared_ptr<base1> b1 = shared_ptr<base1>(new base1(bind(&base2::baseFuc, b2, placeholders::_1)));

    b1->show();

}

古典的Strategy设计模式（将virtual函数替换为另一个继承体系内的virtual函数）

#include <iostream>

#include <string>

#include <memory>

using namespace std;

class base2;

class base1 {

public:

    base1(const shared_ptr<base2>& _b) : b(_b) {}

    void doshow() const;

    void show() const ;

private:

    shared_ptr<base2> b;

};

class base2 {

public:

    virtual void baseFuc(const base1& b) {

        b.doshow();

    }

};

void base1::doshow() const {

    cout << "base1" << endl;

}

void base1::show() const {

    b->baseFuc(*this);

}

int main() {

    shared_ptr<base2> b2 = shared_ptr<base2>(new base2());

    shared_ptr<base1> b1 = shared_ptr<base1>(new base1(b2));

    b1->show();

}

条款36：绝不重新定义继承而来的non-virtual函数

条款37：绝不要重新定义继承而来的缺省参数值

缺省参数值是静态绑定
虚函数是动态绑定

class Base{

public:

    virtual void print(int a = 1) {cout <<"Base "<< a <<endl;};

    int a;

};

class Drive : public Base{

public:

    void print(int a = 2){cout << "Drive " << a <<endl;}

};                                                                                 

int main(){

  Base *b = new Drive;

  b->print();   //   vptr[0](1)

}

//Drive 1

条款38：通过复合塑模树has-a 或“根据某物实现出”

复合（composition）
- has-a（应用域对象间复合）
  - 应用域（程序中塑造的某些事物，如人、汽车、视频画面等等）
- is-implemented-in-terms-of（实现域对象间复合）
  - 实现域（实现细节的人工制品，如缓冲区、互斥器、查找树等等）

条款39：明智而审慎的使用private继承

private继承（不继承接口，但继承实现）
- 编译器不会自动将一个derived class对象转换为base class对象
- base class的所有成员在derived class中都变成private属性
- private继承可以造成empty class最优化（这对致力于"对象尺寸最小化"的程序开发者而言，可能很重要）

class Base{

public:

    void fun(){}

}

//8个字节

class Object{

private:

    int a;

    Base b;

};

//4个字节

class　Object : private Base{

private:

    int a;

}

条款40：明智而审慎的使用多重继承

多重继承可能导致歧义（菱形继承）

class A { ... };

class B: public A { ... };

class C: public A { ... };

class D: public B, public C { ... };

//D中会包含两份A的成员变量

采用virtual继承解决歧义
- virtual继承会增加大小、速度、初始化及赋值等等成本
- 如果base class不带有任何数据，virtual继承比较有实用价值

class A { ... };

class B: virtual public A { ... };

class C: virtual public A { ... };

class D: public B, public C { ... };

//D中只包含一份A的成员变量

有一些情况可采用 "public继承抽象class（继承接口）" 和 "private继承继承协助实现class（继承实现）" 两相结合的方法

巴特西

《Effective C++》继承与面对对象设计：条款32-条款40

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

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

几层作用域:

当前作用域会遮掩上一层作用域的名称（重载的函数也会直接遮掩）

可以通过using声明式（public继承）或者inline转交（public和private继承）解决这一问题

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

条款35：考虑virtual函数以外的其他选择

virtual的替代方案

条款36：绝不重新定义继承而来的non-virtual函数

条款37：绝不要重新定义继承而来的缺省参数值

条款38：通过复合塑模树has-a 或“根据某物实现出”

条款39：明智而审慎的使用private继承

条款40：明智而审慎的使用多重继承

最新文章

热门文章