Effective C++ 条款36、37、38

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

class BaseClass
{
public:
    void NonVirtualFunction()
    {
        cout << "BaseClass::NonVirtualFunction" << endl;
    }
};

class DerivedClass: public BaseClass
{
public:
    void NonVirtualFunction()
    {
        cout << "DerivedClass::NonVirtualFunction" << endl;
    }
};

int main()
{
    DerivedClass d;
    BaseClass* bp = &d;
    DerivedClass* dp = &d;
    bp->NonVirtualFunction(); // 输出BaseClass::NonVirtualFunction
    dp->NonVirtualFunction(); // 输出DerivedClass::NonVirtualFunction
}

从输出结果可以看到一个有趣的现象，那就是两者都是通过相同的对象d调用成员函数NonVirutalFunction，但显示结果却不相同，这会给读者带来困惑。

现在这个现象的原因是在于BaseClass:NonVirutalFunction与DerivedClass:NonVirtualFunction都是静态绑定，所以调用的non-virtual函数都是各自定义的版本。

回顾下之前的条款，如果是public继承的话，那么：

1) 适用于BaseClass的行为一定适用于DerivedClass，因为每一个DerivedClass对象都是一个BaseClass对象；

2) 如果BaseClass里面有非虚函数，那么DerivedClass一定是既继承了接口，也继承了实现；

3) 子类里面的同名函数会掩盖父类的同名函数，这是由于搜索法则导致的。

如果DerivedClass重定义一个non-virtual函数，那么会违反上面列出的法则。以第一条为例，如果子类真的要重定义这个函数，那么说明父类的这个函数不能满足子类的要求，这就与每一个子类都是父类的原则矛盾了。

可以总结一下了，无论哪一个观点，结论都相同：
任何情况下都不该重新定义一个继承而来的non-virtual函数。

条款三十七：绝不重新定义继承而来的缺省参数值

enum MyColor
{
    RED,
    GREEN,
    BLUE,
};

class Shape
{
public:
    void virtual Draw(MyColor color = RED) const = 0;
};

class Rectangle: public Shape
{
public:
    void Draw(MyColor color = GREEN) const
    {
        cout << "default color = " << color << endl;
    }
};

class Triangle : public Shape
{
public:
    void Draw(MyColor color = BLUE) const
    {
        cout << "default color = " << color << endl;
    }
};


int main()
{
    Shape *sr = new Rectangle();
    Shape *st = new Triangle();
    cout << "sr->Draw() = "; // ？
    sr->Draw();
    cout << "st->Draw() = "; // ？
    st->Draw();

    delete sr;
    delete st;
}

问号所在处的输出是什么？

要回答这个问题，需要回顾一下虚函数的知识，如果父类中存在有虚函数，那么编译器便会为之生成虚表与虚指针，在程序运行时，根据虚指针的指向，来决定调用哪个虚函数，这称之与动态绑定，与之相对的是静态绑定，静态绑定在编译期就决定了。
所以color=0

实现动态绑定的代价是比较大的，所以编译器在函数参数这部分，并没有采用动态绑定的方式，也就是说，默认的形参是静态绑定的，它是编译期就决定下来了。
我们看下这两行代码，分析一下：

Shape *sr = new Rectangle();
Shape *st = new Triangle();

sr的静态类型是Shape*，动态类型才是Rectangle*，类似地，st的静态类型是Shape*，动态类型是Triangle*。这里没有带参数，所以使用的是默认的形参，即为静态的Shape::Draw()里面的缺省值RED，所以两个问题所在处的输出值都是0。

正因为编译器并没有对形参采用动态绑定，所以如果对继承而来的虚函数使用不同的缺省值，将会给读者带来极大的困惑，试想一下下面两行代码：

1 Shape *sr = new Rectangle(); // 默认值是RED
2 Rectangle *rr = new Rectangle(); // 默认值是GREEN
如果一定要为虚函数采用默认值，那么只要在父类中设定就可以了，可以借用条款35所说的NVI方法，像下面这样：

class Shape
{
public:
    void DrawShape(MyColor color = RED)
    {
        Draw(color);
    }
private:
    virtual void Draw(MyColor color) const = 0
    {
        cout << "Shape::Draw" << endl;
    }
};

class Rectangle: public Shape
{
private:
    void Draw(MyColor color) const
    {
        cout << "Rectangle::Draw" << endl;
    }
};

class Triangle : public Shape
{
private:
    void Draw(MyColor color) const
    {
        cout << "Triangle::Draw" << endl;
    }
};


int main()
{
    Shape *sr = new Rectangle();
    Shape *st = new Triangle();
    cout << "sr->DrawRectangle() = "; // Rectangle::Draw
    sr->DrawShape();
    cout << "st->DrawTriangle() = "; // Triangle::Draw
    st->DrawShape();
    delete sr;
    delete st;
}

因为前面条款已经约定non-virtual函数不会被覆写，所以这样就不用担心在子类中出现定义不同缺省形参值的问题了。

最后总结一下：

绝对不要重新定义一个继承而来的缺省参数值，因为缺省参数值都是静态绑定，而virtual函数——你唯一应该覆写的东西——却是动态绑定。

条款三十八：通过复合塑模出has-a或者is-implemented-in-terms-of

如果说public是一种is-a的关系的话，那么复合就是has-a的关系。直观来说，复合就是在一个类中采用其他类的对象作为自身的成员变量，可以举个例子，像下面这样：

class Person
{
private:
    string Name; // 复合string类型的变量
    PhoneNumber HomeNumber; // 复合PhoneNumber对象
    PhoneNumber TelephoneNumber;
};

我们一般会说人有名字，有家庭电话，有手机电话等，但我们一般不会说人是一个名字，或者人是一个家庭电话等。所以在这里，我们并不会去使用public继承表现出来的is-a关系，而是使用“拥有”这样的has-a关系。

复合的目的就是在Person类里面可以很自然地操作Person的属性，比如输出HomeNumber，查询HomeNumber等，这些可以调用PhoneNumber里面现成的成员函数。标准库里的string类型更是集成了丰富的成员方法，可以方便我们对Name进行各种各样的操作。
除了has-a关系外，复合还有一种含义，那就是is-implemented-in-terms-of，这说起来有些长，中文的意思是据某物实现出。举书上的例子，假定我们需要利用list来实现set，如果采用的是继承，像这样：
class MySet: public list
{
…
}
那就麻烦了，还记得我们在最初讲public继承时，就说了，public继承链下有Liskov法则，即父类存在的地方一定可以被子类所替代。这个例子里父类是list，子类是MySet，如果用MySet去替换list，那么就会有问题，因为list是支持重复元素的，如果连续执行两次list.push_back(1)，那么list里面会有两个1元素，但换成MySet，结果却只会有一个1元素（因为Set是不重复元素的集合）。那怎么办呢，我们既想利用list现有的特性，也不想违反可替代法则。
方法就是复合，像下面这样：

template <class T>
class MySet
{
    list<T> MyList;
    …
}

这样就可以放心使用list现有的方法去实现MySet的功能了，具体的示例代码如下：

#include <iostream>
#include <list>
using namespace std;
template <class T>
class MySet
{
private:
    list<T> MyList;

public:
    int Size() const
    {
        return MyList.size();
    }

    bool IsContained(T Element) const
    {
        return (find(MyList.begin(), MyList.end(), T) != MyList.end());
    }

    bool Insert(T Element)
    {
        if (!IsContained(T))
        {
            MyList.push_back(Element);
            return true;
        }
        else
        {
            return false;
        }
    }

    bool Remove(T Element)
    {
        list<T>::iterator Iter = find(MyList.begin(), MyList.end(), T);
        if (Iter != MyList.end())
        {
            MyList.erase(Iter);
            return true;
        }
        else
        {
            return false;
        }
    }
};

好，到目前为止，大家应该能理解什么叫is-implemented-in-terms-of了吧，就是依据某物来实现，就像这里的set，就是依据于list来实现自身的结构的，这种情况下也用has-a复合模型。

最后总结一下：

1. 复合的意义和public继承完全不同；
2. 在应用域，复合意味着has-a（有一个），在实现域，复合意味着is-implemented-in-terms-of（根据某物实现出）。