《Effective C++》继承与面对对象设计:条款32-条款40
条款32:确定你的public继承塑模出is-a关系
- public继承意味着is-a。适用于base class身上的每一个函数也一定适用于derived class。
条款33:避免遮掩继承而来的名称
几层作用域:
- global作用域
- namespace作用域
- Base class作用域
- Drive class作用域
- 成员函数
- 控制块作用域
- 成员函数
- Drive class作用域
- Base class作用域
- namespace作用域
当前作用域会遮掩上一层作用域的名称(重载的函数也会直接遮掩)
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(实现域对象间复合)
- 实现域(实现细节的人工制品,如缓冲区、互斥器、查找树等等)
- has-a(应用域对象间复合)
条款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(继承实现)" 两相结合的方法