条款 41: 区分继承和模板

结论：

当对象的类型不影响类中函数的行为时，就要使用模板来生成这样一组类。

当对象的类型影响类中函数的行为时，就要使用继承来得到这样一组类。

下面的代码通过定义一个链表来实现 Stack 类，假设堆栈的对象类型为 T：

class Stack {
public:
Stack();
~Stack();
void push(const T& object);
T pop();
bool empty() const; //  堆栈为空?
private:
struct StackNode { //  链表节点
T data; //  此节点数据
StackNode *next; //  链表中下一节点
// StackNode 构造函数，初始化两个域
StackNode(const T& newData, StackNode *nextNode)
: data(newData), next(nextNode) {}
};
StackNode *top; //  堆栈顶部

Stack(const Stack& rhs); //  防止拷贝和
Stack& operator=(const Stack& rhs); //  赋值(见条款 27)
};

Stack::Stack(): top(0) {} //  顶部初始化为 null
void Stack::push(const T& object)
{
top = new StackNode(object, top); //  新节点放在
} //  链表头部
T Stack::pop()
{
StackNode *topOfStack = top; //  记住头节点
top = top->next;
T data = topOfStack->data; //  记住节点数据
delete topOfStack;
return data;
}
Stack::~Stack() //  删除堆栈中所有对象
{
while (top) {
StackNode *toDie = top; //  得到头节点指针
top = top->next; //  移向下一节点
delete toDie; //  删除前面的头节点
}
}
bool Stack::empty() const
{ return top == 0; }

        这些代码毫无吸引人之处。实际上，唯一有趣的一点在于：即使对 T 一无所知，你还是能够写出每个成员函数。 （上面的代码中实际上有个假设，即，假设可以调用 T 的拷贝构造函数；但正如条款 45 所说明的，这是一个绝对合理的假设）不管 T 是什么，对构造，销毁，压栈，出栈，确定栈是否为空等操作所写的代码不会变。除了"可以调用 T 的拷贝构造函数"  这一假设外，stack 的行为在任何地方都不依赖于 T。这就是模板类的特点：行为不依赖于类型。
        

       另一种情况：

      作为一位爱猫的宠物迷，你想设计一个类来表示猫。这也将需要多个不同的类，因为每个品种的猫都会有点不同。和所有对象一样，猫可以被创建和销毁，但，正如所有猫迷所知道的，猫所做的其它事不外乎吃和睡。然而，每一种猫吃和睡都有各自惹人喜爱的方式。

      注意这一条："每一种猫吃和睡都有各自惹人喜爱的方式"。这意味着必须为每种不同的猫实现不同的行为。不可能写一个函数来处理所有的猫，所能做的只能是制定一个函数接口，所有种类的猫都必须实现它。啊哈！衍生一个函数接口的方法只能是去声明一个纯虚函数

class Cat {
public:
virtual ~Cat(); //  参见条款 14
virtual void eat() = 0; //  所有的猫吃食
virtual void sleep() = 0; //  所有的猫睡觉
};

class Siamese: public Cat {
public:
void eat();
void sleep();
...
};

class BritishShortHairedTabby: public Cat {
public:
void eat();
void sleep();
...
};

总结：

代码重用的两种主要方式是，模板和继承：

模板：当对象的类型不影响类中函数的行为时，就要使用模板来生成这样一组类。

            当对象的类型影响类中函数的行为时，就要使用继承来得到这样一组类。