Effective C++ 学习笔记（五）

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

（1）public继承意味is-a，适用于base class身上的每一件事情一定也适用于derived classes身上，因为每一个devided class对象也是一个base class对象，但是每一个适用于devided class对象身上的每一件事情并不一定适用于base class。

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

（1）derived class内的名称会遮掩base classes内的名称，就像局部对象会遮掩全局对象一样

#include<iostream>
using namespace std;

class Base
{
private:
    int x;
public:
    virtual void mf1() = 0;
    virtual void mf1(int a)
    {
        cout << "Base::mf1(int a):"<< a << endl;
    }
    virtual void mf2()
    {
        cout <<"Base::mf2:" << endl;
    }
    void mf3()
    {
        cout << "Base::mf3:" << endl;
    }
    void mf3(double a)
    {
        cout << "Base::mf3(double)" << a << endl;
    }
};

class Derived:public Base
{
public:
    using Base::mf1;  //让base class内名为mf1和mf3的所有东西在derived作用域内可见
    using Base::mf3;
    virtual void mf1()
    {
        cout << "Derived::mf1:"<< endl;
    }
    void mf3()
    {
        cout << "Derived::mf3:"<<endl;
    }
    void mf4()
    {
        cout << "Derived::mf4" << endl;
    }
};


void main()
{
    Derived d;
    int x = 10 ;

    d.mf1();
    d.mf1(x);
    d.mf2();
    d.mf3();
    d.mf3(x);
}

如果在derived中不加using Base::mf1和using Base::mf3这两句话的话，derived中的mf1函数就会把Base类中的mf1函数遮掩掉，在调用d.mf1（x）和d.mf3(x)时就会编译报错，说找不到这样的函数，这是因为derived中的mf1等函数将base类中这样的函数遮掩掉了。

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

（1）身为class的设计者，有时候你希望derived class只继承成员函数的接口（也就是声明）；有时候你希望derived classes同时继承函数的接口和实现，但有希望能够覆写（override）他们所继承的实现;有时你希望derived class同时继承函数的接口和实现，并且不允许覆写任何东西。为了实现这些功能可以用pure virtual实现只继承接口，impure virtual实现继承接口和实现并能覆写，一般的函数能够实现继承接口和实现但不能覆写。

（2）因为impure virtual实现继承接口和实现并能覆写，如果子类并不想使用默认继承来的impure virtual的话，该怎么解决呢？

#include<iostream>
using namespace std;

class Base
{
public:
virtual void print() =0; //迫使子类必须实现该接口
};
void Base::print()//为子类提供一个可以调用的函数，但是必须是自己调用
{
    cout <<"Base::print()" << endl;
}

class Derived:public Base
{
public:
    
 void print()
 {
     Base::print();
     //cout << "Derived::print()" << endl;
 }
};

void main()
{
   Base *pBase = new Derived;
   pBase->print();
}

可以使用这种解决办法，为virtual函数提供一个默认的实现，因为子类必须要实现virtual函数，所以子类就不会默认的继承父类已经实现过的方法，子类可以调用父类提供的默认实现方法，但是调用该方法必须的是子类显式的调用，这样就能避免子类默认情况下继承父类的impure virtual函数的问题。

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

（1）藉由Non-Virtual Interface手法实现Template Method模式

#include<iostream>
using namespace std;

class GameCharacter
{
public:
    int healthValue() const
    {
        ..... //做一些事前工作
        int retVal = doHealthValue();
        ..... //做一些事后工作
    }
private:
    virtual int doHealthValue() const
    {
        .....
    }
};

在这个类中，在healthValue函数中，调用了doHealthValue（）这个虚函数，在调用这个虚函数之前做了一些初始化工作，在调用这个函数之后又做了一些初始化工作，这些都可以看做是骨架，doHealthValue（）这个虚函数可以延后在子类中进行扩充，这就是设计模式中的template模式。

（2）藉由Funtion Pointers实现Strategy模式

这个方法的思想是，在这个类中保存另一个类的指针或者对象，通过保存的指针或对象调用该对象的方法，实现Strategy模式。可以将类中的virtual函数都替换为指针成员变量，这样比virtual更加灵活。不需要构造更多的类。

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

（1）如果重新定义了继承而来的non-virtual函数，就会出现遮掩现象（子类的方法这样父类的方法），并且non-virtual函数体现的是不变性，如果要在子类中重新定义这个函数，就说明这个函数是要在子类中改变的就不应该是non-virtual函数而应该是virtual函数。

#include<iostream>
using namespace std;
class B
{
public:
    void mf()
    {
        cout << "B::mf" << endl;
    }
};
class D:public B
{
public:
    void mf()
    {
        cout << "D::mf" << endl;
    }
};
void main()
{
    D x;
    B *pB = &x;
    pB->mf();
    D *pD = &x;
    pD->mf();
}

这将因为指针的类型决定调用的是谁的函数的问题，而virtual函数不存在这样的问题。绝对不要重新定义继承而来的non-virtual函数。

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

（1）因为virtual函数是动态绑定的，而缺省参数却是静态绑定的，所以函数调用的是子类的virtual函数，但是参数却是父类的缺省参数，即使子类中也定义了参数的缺省参数，使用的仍是父类的缺省参数。

#include<iostream>
using namespace std;
class Shape
{
public:
    enum ShapeColor{ Red,Green,Blue};
    virtual void draw( ShapeColor color = Red ) const = 0;
};

void Shape::draw(ShapeColor color) const 
{
    cout << color << endl;
}
class Rectangle: public Shape
{
public:
    virtual void draw( ShapeColor color = Green ) const
    {
        cout << color << endl;
    }
};
class Circle :public Shape
{
public:
    virtual void draw( ShapeColor color) const
    {
        cout << color << endl;
    }
};
void main()
{
    Shape *ps1;
    ps1 = new Rectangle;
    ps1->draw();
    delete ps1;
    Shape *ps2;
    ps2 = new Circle;
    ps2->draw();
    delete ps2;
}

（2）在遇到virtual函数的缺省参数时，可以使用下面的方法来替代设计。

#include<iostream>
using namespace std;
class Shape
{
public:
    enum ShapeColor{ Red,Green,Blue};
    void draw( ShapeColor color = Red ) const
    {
        doDraw( color );
    }
private:
    virtual void doDraw( ShapeColor color ) const = 0;
};

void Shape::doDraw(ShapeColor color) const 
{
    cout << color << endl;
}
class Rectangle: public Shape
{
public:
    virtual void doDraw( ShapeColor color ) const
    {
        cout << color << endl;
    }
};

因为non-virtual函数绝对不被derived class 覆写，这个设计很清楚的使用color的缺省参数值。

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

（1）复合的意义和public继承完全不同。public继承是is-a，复合的意义是has-a，is-a体现的是子类是父类，has-a体现的是一个类中有另外一个类，但两个类不能相互替代，如果类A包含了类B，则类A可以调用类B的函数。

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

（1）如果是类Dpublic继承类B，体现的是is-a，所以类D可以自动将类D转化成类B，如果是private继承，那么体现的将不是is-a，private体现的是类D和类B是没有必然的联系，只是类D想使用类B的一些方法或者函数，类D和类B之间没有必然的联系，所以呢类D将不会自动转化为类B。如下面程序：

#include<iostream>
using namespace std;
class B
{
public:
    int x;
    virtual void print()
    {
        cout << "B::print" << endl;
    }
};
class D: private B
{
public:
    virtual void print()
    {
        cout << "D::print" << endl;
    }
};

void callPrint( B &rb )
{
    rb.print();
}
void main()
{
   B b;
   D d;
   callPrint( b );
   callPrint( d );//将会报错：error C2243: 'type cast' : conversion from 'class D *' to 'class B &' exists, but
                   //is inaccessible
}

（2）private继承和复合的作用都是使用某些类的方法，那么两者怎么取舍呢？首先，看下面的例子：

#include<iostream>
using namespace std;
class Empty
{
};

class HoldAnInt
{
private:
    int x;
    Empty e;//应该不需要任何内存的
};

会发现sizeof(HoldAnInt)>sizeof(int),因为大小为0的独立对象，c++官方勒令安插一个char（或其它如int）到空对象内，所以呢这样的话用private会比较节省空间，对于要节省空间很重要。

如果要是用private继承的话，如果子类就可以改写父类的一些方法，可能我们的本意只是想让子类使用这些方法，这将违背我们的意愿，所以这时候用组合还是比较好。

（3）C++也可以使用类中类

#include<iostream>
using namespace std;
class Empty
{
public:
    class test
    {
    public:
        void print()
        {
            cout << "Empty::test::print" << endl;
        }
    };
    test t;
};

void main()
{
    Empty e;
    e.t.print();
}

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

（1）多重继承容易导致歧义，以及钻石型多重继承，导致子类拥有多个父类的成员。