关于OOP
1，继承可以是单一继承或多重继承，每一个继承连接可以是public、protected或private，也可以是virtual或non-virtual。
2，成员函数的各个选项：virtual或non-virtual或pure-virtual。
3，成员函数和其他语言特性的交互影响：缺省参数值与virtual函数有什么交互影响？继承如何影响C++的名称查找规则？设计选项有如些？如果class的行为需要修改，virtual函数是最佳选择吗？
4，public继承意味着“is-a”。
5，virtual函数意味着“接口必须被继承”，non-virtual意味着“接口和实现都必须被继承”。
条款32：确定你的public继承塑模出is-a关系
“public继承”意味着is-a。适用于base classes身上的每一件事情一定也适合于derived class身上，因为每个derived classes对象也都是一个base classes对象。
上面这种关系听起来颇为简单，但有时候你的直觉可能会误导你，比如，企鹅是一种鸟，这是事实。鸟可以飞，这也是事实，但是如果在用类描述时把企鹅定义为鸟的public继承则会出问题，比如给基类定义fly函数。
条款33：避免遮掩继承而来的名称
derived classes内的名称会遮掩base classes内的名称。在public继承下从来没有人希望如些。
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(); //屏蔽了Base里的mf1(int)
void mf3(); // 屏蔽了Base里的mf3
void mf4();
};
Derived d; int x; d.mf1(); //ok,调用Derived::mf1 d.mf1(x); //error，因为Derived::mf1遮掩Base=::mf1 d.mf2(); //ok,调用Base::mf2 d.mf3(); //ok,调用Derived::mf3 d.mf3(x); // error，因为Derived::mf3遮掩了Base::mf3
Derived内的函数遮掩了Base内所有的同名函数。当然实现中如果是一种public继承，则是一定需要同理继承重载函数的，因为必须符合is-a关系。
我们可以用using声明式达成目标：
class Derived :public Base
{
public:
using Base::mf1;
using Base::mf3;
virtual void mf1();
void mf3();
void mf4();
};
Derived d; int x; d.mf1(); //ok,仍然调用Derived::mf1 d.mf1(x); //现在没有问题了 d.mf2(); //ok,调用Base::mf2 d.mf3(); //ok,仍然调用Derived::mf3 d.mf3(x); //没有问题了
我们还可以使用交换函数来完成这个功能：有时候我们并不想继承base classes的所有函数。
class Derived :private Base
{
public:
virtual void mf1() // 转交函数
{
Base::mf1();
}
};
条款34：区分接口继承和实现继承
接口继承和实现继承不同。在public继承之下，derived classes总是继承base class的接口。
pure virtual函数只具体指定接口继承
简朴的（非纯）impure virtual函数具体指定接口继承及缺省实现继承。
non-virtual函数具体指定接口继承以及强制性实现继承
条款35：考虑virtual函数以外的其他选择
这条款谈了两种设计模式，鼓励我们多思考的。
以游戏中的人物设计继承体系为例子，不同的人物有不同的计算健康指数的方法，就叫healthValue函数吧，很自然的就会想到设计一个基类，把healthValue函数设计为virtual的用于继承。
此条款提供了两种不同的思路，用于virtual替代方案：
1. Template Method模式，由Non-Virtual Interface手法实现。
具体到以上的例子就是大概如下：
class GameCharacter {
public:
int healthValue() const {
// ...
int retVal = doHealthValue();
// ...
return retVal;
}
private:
virtual int doHealthValue() const {
}
};
其实最先提的把healthValue设计为virtual的方法也是Template Method模式，而这里就是保留healthValue为public，而实现为private virtual（当然这里是可以protected的），这样的好处在于其中的前后“...”（省略号），这部分可以进行一些类似检查、调整的操作，保证doHealthValue()在一个适当的场景下调用。而且子类也可以继承实现private virtual成员函数。
2. Strategy模式，这一模式令实现方法是个变量，就算是同一个对象在不同的时段也可以有不同的实现方法。但这里都有个约束，就是对私有成员变量的访问限制。
a) Function Pointers实现，此种实现手法的约束是只能是函数，而且形式受函数的签名（参数数量，参数类型，返回类型）的约束。
b) tr1::function实现，摆脱了a)的约束，支持隐式类型转换，还支持函数对象或者是成员函数（通过std::tr1::bind实现）
c) 古典实现，其实就是对象实体是一类，而实现方法是另一类。
条款36：绝对不重新定义继承而来的non-virtual函数
当派生类中重新定义了基类中的non-virtual函数时，如果用指向基类类型的指针(实际指向派生类对象)来访问该non-virtual函数时，访问的是基类对象的non-virtual函数。
造成上面行为的原因是，non-virtual是静态绑定的，区别于virtual函数的动态绑定。
条款37：绝不重新定义继承而来的缺省参数值
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 = 0;
};
上面的代码中，如果我们定义了一个类型为Shape*的指针指向Rectangle。
Shape* ps=new Rectangle;
ps->draw();
我们的实际愿望可能是希望让draw的默认参数为Green，但是实际上确是Red，因为默认参数是静态绑定的。
也许你可能会想让派生类的中virtual函数和base类中保持一致。但是下面的代码显然也是不可行的。
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 = Red)const = 0;
};
上面不仅会产生代码重复，而且带来了相依性（如果Shape内的缺省参数变了，所有派生类的virtual函数缺省值都要修改）。
聪明的做法是考虑替代设计，如条款35中的一些virutal函数的替代设计，其中之一是NVI手法，令base class内的一个public non-virtual函数调用private virtual函数。
class Shape
{
public:
enum ShapeColor{ Red, Green, Blue };
virtual void draw(ShapeColor color = Red)const
{
doDraw(color);
}
private:
virtual void doDraw(ShapeColor color)const = 0;
};
class Rectangle :public Shape
{
private:
virtual void doDraw(ShapeColor color)const;
};
条款38：通过复合塑模出has-a或“根据某物实现出”
复合或包含意味着has-a。如果我们想设计一个自己的set，我们思考后觉得可以用list来实现它，但是如果我把它设计出list的一个派生类，就会有问题，因为父类的所有行为在派生类都是被允许的，而list允许元素重复，而set则显然不行，所以set与list之间不符合is-a关系，我们可以把list设计为set的一个成员，即包含关系（has-a）。
条款39：明知而审慎地使用private继承
private继承意味着is-implemented-in-terms of(根据某物实现)。它通常比复合的级别低。但是当derived class需要访问protected base class的成员，或需要重新定义继承而来的virtual函数时，这么设计是合理的。
和复合不同，private继承可以造成empty base最优化。这对致力于“对象尺寸最小化”的程序库开发者而言，可能很重要。
class Empty{};
class HoldsAnInt
{
private:
int x;
Empty e;
};
这时候你会发现sizeof(HoldsAnInt)>sizeof(int)，因为一些内存对齐的要求。
而如果是：
class HoldsAnInt :private Empty{
private:
int x;
};
这时候几乎可以肯定：sizeof(HoldsAnInt)==sizeof(int)。
条款40：明智而审慎地使用多重继承
使用多重继承就要考虑歧义的问题（成员变量或者成员函数的重名）。
最简单的情况的解决方案是显式的调用（诸如item.Base::f()的形式）。
复杂一点的，就可能会出现“钻石型多重继承”，以File为例：
class File { ... }
class InputFile : public File { ... }
class OutputFile : public File { ... }
class IOFile : public InputFile, public OutputFile { ... }
这里的问题是，当File有个filename时，InputFile与OutputFile都是有的，那么IOFile继承后就会复制两次，就有两个filename，这在逻辑上是不合适的。解决方案就是用virtual继承：
class File { ... }
class InputFile : virtual public File { ... }
class OutputFile : virtual public File { ... }
class IOFile : public InputFile, public OutputFile { ... }
这样InputFile与OutputFile共享的数据就会在IOFile中只保留一份了。
但是virtual继承并不常用，因为：
1. virtual继承会增加空间与时间的成本。
2. virtual继承会非常复杂（编写成本），因为无论是间接还是直接地继承到的virtual base class都必须承担这些bases的初始化工作，无论是多少层的继承都是。
请记住
多重继承比单一继承复杂。它可能导致新的歧义性，以及对virtual继承的需要。
virtual继承会增加大小、速度、初始化（赋值）复杂度等等成本。如果virtual base classes不带任何数据，将是最具实用价值的情况。
多重继承的确有正当用途。其中一个情节涉及“public继承某个Interface class”和“private继承某个协助实现的class”的两相组合。