effective c++：virtual函数的替代方案

绝不重新定义继承来的缺省值

首先明确下，虚函数是动态绑定，缺省参数值是静态绑定

// a class for geometric shapes

class Shape {

public:

　　enum ShapeColor { Red, Green, Blue };

　　// all shapes must offer a function to draw themselves

　　virtual void draw(ShapeColor color = Red) const = 0;

　　...

};

class Rectangle: public Shape {

public:

　　// notice the different default parameter value — bad!

　　virtual void draw(ShapeColor color = Green) const;

　　...

};

class Circle: public Shape {

public:

　　virtual void draw(ShapeColor color) const;

　　...

};

 

当我们这样指定这些指针时。

Shape *ps; // static type = Shape*

Shape *pc = new Circle; // static type = Shape*

Shape *pr = new Rectangle; // static type = Shape*

 

三个对象的静态类型均为Shape*,这时调用它们的虚函数：

pc->draw(Shape::Red); // calls Circle::draw(Shape::Red)

pr->draw(Shape::Red); // calls Rectangle::draw(Shape::Red)

 

由于虚函数是动态绑定的，所以pc,pr调用各自的draw没错，但是却是用的时shape中draw指定的Red参数值，当运行这段代码时，画出来的图像可能就是个四不像。

所以如果基类成员虚函数中定义了缺省值，就不能用常规的方法来使用它，我们需要考虑它的替代设计：

class Shape {

public:

enum ShapeColor { Red, Green, Blue };

void draw(ShapeColor color = Red) const // now non-virtual

{

　　doDraw(color); // calls a virtual

}

...

private:

virtual void doDraw(ShapeColor color) const = 0; // the actual work is

}; // done in this func



class Rectangle: public Shape {

public:

　　...

private:

　　virtual void doDraw(ShapeColor color) const; // note lack of a

　　... // default param val.

};

 

派生类可以重新定义虚函数，而且可以指定自己独有的color,而non-virtual函数draw按照c++设计原则是不应该被重写的。这种方法称为non-virtual interface，但是有一些函数根据实际需求必须是public，比方多态性质的基类析构函数，这样一来就不能使用NVI了。

tr1::function实现Strategy设计模式

class GameCharacter; // as before

int defaultHealthCalc(const GameCharacter& gc); // as before

class GameCharacter {

public:

　　// HealthCalcFunc is any callable entity that can be called with

　　// anything compatible with a GameCharacter and that returns anything

　　// compatible with an int; see below for details

　　typedef std::tr1::function<int (const GameCharacter&)> HealthCalcFunc;

　　: healthFunc(hcf )

　　{}

　　int healthValue() const

　　{ return healthFunc(*this); }

　　　　...

private:

　　HealthCalcFunc healthFunc;

};

 

上例中我们把HealthCalcFunc声明为一个typedef，他接受一个GameCharacter引用类型的参数，返回int.tr1::function的功能是使可调物的参数隐式的转换为const GameCharacter&，同理返回类型隐式的转换为int。

我们可以调用改函数进行计算，使用这种方式来替代虚函数的设计避免了NVI的问题，又展现了出色的兼容性。

short calcHealth(const GameCharacter&); // health calculation

// function; note

// non-int return type

struct HealthCalculator { // class for health

int operator()(const GameCharacter&) const // calculation function

{ ... } // objects

};

class GameLevel {

public:

float health(const GameCharacter&) const; // health calculation

... // mem function; note

}; // non-int return type

class EvilBadGuy: public GameCharacter { // as before

...

};

class EyeCandyCharacter: public GameCharacter { // another character

... // type; assume same

}; // constructor as

// EvilBadGuy

EvilBadGuy ebg1(calcHealth); // character using a

// health calculation

// function

EyeCandyCharacter ecc1(HealthCalculator()); // character using a

// health calculation

// function object

GameLevel currentLevel;

...

EvilBadGuy ebg2( // character using a

std::tr1::bind(&GameLevel::health, // health calculation

currentLevel, // member function;

_1) // see below for details

);

 

为了计算ebg2的健康指数，应该使用GameLevel class的成员函数health。GameLevel::haelth宣称它自己接受一个参数（那是个引用指向GameCharacter）,但它实际上接受两个参数，因为它也获得了一个隐式参数gameLevel，也就是this所指的那个。然而GameCharacter的健康计算函数只接受单一参数：GameCharacter（这个对象将被计算出健康指数）。如果我们使用GameLevel::health作为ebg2的健康计算函数，我们必须以某种方式转换它，使它不再接受两个参数（一个GameCharacter和一个GameLevel），转而接受单一参数（一个GameCharacter）。这个例子中我们必然会想要使用currentLevel作为“ebg2的健康计算函数所需的那个GameLevel对象”，于是我们将currentLevel绑定为GameLevel对象，让它在“每次GameLevel::health被调用以计算ebg2的健康”时被使用。那正是tr1::bind的作为:它指出ebg2的健康计算函数总是以currentLevel作为GameLevel对象。

传统Strategy模式

class GameCharacter; // forward declaration

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;

};

这个设计方案是将virtual函数替换为另一个继承体系中的virtual函数。