Effective C++笔记_条款35 考虑virtual 函数以外的其他选择

    因为其他的事情耽误了看书，现在将看的笔记记录下来。

class GameCharacter {
 public:
     virtual int healthValue() const;
 };

1. 藉由Non-Virtual Interface 手法实现 Template Method模式
（1）non-virtual interface（NVI）：
　　令客户通过public non-virtual 成员函数间接调用private virtual函数
（2） virtual 函数的外覆器（wrapper）:non-virtual 函数

class GameCharacter {
 public:
     int healthValue() const    // virtual 函数的外覆器（wrapper）
     {
         //...
         /*
          做些事前工作：锁定互斥器，制造运转日志记录项，验证class约束条件、验证函数先决条件等等
         */
         int retVal = doHealthValue();
         //...
         /*
         做些事后工作：互斥器解除锁定，验证函数的时候条件、再次验证class约束条件等等。
         */
         return retVal;
     }
 private:
     virtual int doHealthValue() const
     {
         //...
     }
 };

优点：
　　先比于直接调用virtual 函数，就没有任何好办法可以处理事前和时候工作。
注意事项：
　　重新定义virtual 函数，表示某些事“如何”被完成，“调用virtual 函数”则表示它“何时”被完成。

　　NVI手法允许derived classs重新定义virtual函数，从而赋予他们“如何实现机能”的控制能力，但base class保留诉说“函数何时被调用”的权利。

---

2.藉由Function Pointers 实现Strategy模式

class GameCharacter;    // forward declaration

 int defaultHealthCalc(const GameCharacter& gc);    /*计算健康指数的缺省算法*/
 class GameCharacter {
 public:
         typedef int (*HealthCalcFunc) (const GameCharacter&);
         explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc)
             :healthFunc(hcf)
         {}

         int healthValue() const
         {
             return healthFunc(*this);
         }
 private:
     HealthCalcFunc healthFunc;
 };

上述模式的解释说明：
（1）同一任务类型的不同实体可以不同的健康计算函数。e.g:

class EvilBadGuy:public GameCharacter {
public:
    explicit EvilBadGuy(HealthCalcFunc hcf = defaultHealthCalc)
        :GameCharacter(hcf)
    {
        //...
    }
};

int loseHealthQuickly(const GameCharacter&);
int loseHealthSlowly(const GameCharacter&);

/* 相同类型的的人物搭配不同的健康计算方式 */
EvilBadGuy ebg1(loseHealthQuickly);
EvilBadGuy ebg2(loseHealthSlowly);

(2)某已知人物的健康指数计算函数可在运行期变更。

　　例如GameCharacter提供一个setHealthCalculator函数，用来替换当前的健康指数计算函数。

（3）一般而言，唯一能够解决“需要以non-member函数访问class的non-public成分”的办法是：弱化class的封装。例如，class可声明那个non-member函数为friends或为其实现的某一部分提供public访问函数。
　----> 藉由Function Pointers 实现Strategy模式的缺点是：弱化了class的封装性。

---

 3.藉由tr1::function完成Strategy模式

class GameCharacter;
 int defaultHealthCalc(const GameCharacter& gc);
 class GameCharacter {
 public:
         /*
         HealthCalcFunc 可以是任何“可调用物”(callable entity),可被调用并接受任何兼容于
         GameCharacter的事物（参数可被隐式转换为const GameCharacter&），
         返回任何兼容于int的东西（可被隐式转换为int）。

         类似一个指向函数的泛化指针
         */
         typedef std::tr1::function<int (const GameCharacter&)> HealthCalcFunc;
         explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc)
             :healthFunc(hcf)
         {}

         int healthValue() const
         {
             return healthFunc(*this);
         }
 private:
     HealthCalcFunc healthFunc;

 };

/*健康计算函数，注意其返回类型为non-int*/
 short calcHealth(const GameCharacter&); 

/*为计算健康而设计的函数对象*/
 struct HealthCalculator {
     int operator() (const GameCharacter&) const
     {
         //...
     }
 };

 class GameLevel {
 public:
     /*成员函数，用以计算健康；注意其non-int返回类型*/
     float health(const GameCharacter&) const;
     //...
 };

class EvilBadGuy:public GameCharacter {
public:
    explicit EvilBadGuy(HealthCalcFunc hcf = defaultHealthCalc)
        :GameCharacter(hcf)
    {
        //...
    }
};

class EyeCandyCharacter:public GameCharacter {
public:
    explicit EyeCandyCharacter(HealthCalcFunc hcf = defaultHealthCalc)
        :GameCharacter(hcf)
    {
        //...
    }
};

/*使用函数计算健康指数*/
EvilBadGuy ebg1(calcHealth); 
/*使用某个函数对象计算健康指数*/ 
EyeCandyCharacter eccl(HealthCalculator());    

/*使用某个成员函数计算健康指数*/
GameLevel currentLevel;
EvilBadGuy ebg2(std::tr1::bind(&GameLevel::health, currentLevel, _l));

---

4.古典的Strategy模式
　　传统的Strategy做法会将健康计算函数做成一个分离的继承体系中的virtual成员函数

class GameCharacter;
class HealthCalcFunc {
public:
    //...
    virtual int calc(const GameCharacter& gc) const
    {
        //...
    }
    //...
};

HealthCalcFunc defaultHealthCalc;
class GameCharacter {
public:
    explicit GameCharacter(HealthCalcFunc* phcf = &defaultHealthCalc)
        :pHealthCalc(phcf)
    {}

    int healthValue() const
    {
        return pHealthCalc->calc(*this);
    }

    //...
private:
    HealthCalcFunc *pHealthCalc;
};

---

5.总结

　　当你为解决问题而寻找某个设计方法时，不妨考虑virtual函数的替代方案。
　　(1)使用non-vvirtual interface(NVI)手法，它以public non-virtual 成员函数包裹较低
　　　　访问性(private或protected)的virtual函数。

　　(2)将virtual函数替换为“函数指针成员变量”。

　　(3)以tr1::function 成员变量替换virtual,因而允许使用任何可调用物搭配一个兼容与需求的签名式。

　　(4)将继承体系内的virtual函数替换为另一个继承体系的virtual函数。

---

注明：全文文字都是来源《Effective C++》 3th。这里所写都是自己的读书的时候梳理做的笔记罢了。希望对他人有用，那是我的荣幸。