Effective C++ 學習筆記（十）繼承與面向對象設計（二）std::function、std::bind、strategy模式、動态綁定、靜态綁定

Effective C++ 學習筆記（十）繼承與面向對象設計（二）

條款 35 考慮virtual之外的其他選擇

（1）使用Non-Virtual手法實作Template Method的方法

C++中derived class可重新定義繼承而來的private virtual 函數

class GameCharacter
{
public:
    int healthValue() const; // 在基類中定義non-virtual函數，在private virtual函數中實作可變算法。在non-virtual函數中調用virtual函數，保證處理的順序。

private:
    virtual int doHealthValue() const; // 可變的算法寫到private virtual中。
};

int GameCharacter::healthValue() const
{
    cout<<"計算健康值前的處理……"<<endl;
    int retVal = doHealthValue();
    cout<<"計算健康值後的處理……"<<endl;
    return retVal;
}

int GameCharacter::doHealthValue() const
{
    cout<<"預設的健康值計算方式"<<endl;
    return 0;
}

class GameCharacterA : public GameCharacter
{
private:
    int doHealthValue() const; // 在派生類中隻要重寫基類中的private virtual中就可以了。
};

int GameCharacterA::doHealthValue() const
{
    cout<<"角色A的健康值計算方式"<<endl;
    return 0;
}

void main()
{
    GameCharacter* gc = new GameCharacterA();
    gc->healthValue();
}
           

（2）藉由tr1::function 完成 strategy模式

C++中 std::tr1::function:

類模闆std :: function是一個通用的多态函數包裝器。 std :: function的執行個體可以存儲，複制和調用任何可調用對象，如函數，lambda表達式，綁定表達式（bind）或其他函數對象，以及指向成員函數和指向資料成員的指針。

存儲的可調用對象稱為std::unction的target。 如果std :: function不包含target，則将其稱為空。 調用空std :: function的target會導緻抛出std :: bad_function_call異常。

std :: function滿足CopyConstructible和CopyAssignable的要求。

常用通項文法： std::function<return-type(args-list)> renamed_f = init_function_name;

常見的應用場景：

#include <functional>
#include <iostream>
 
struct Foo {
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout << num_+i << '\n'; }
    int num_;
};
 
void print_num(int i)
{
    std::cout << i << '\n';
}
 
struct PrintNum {
    void operator()(int i) const
    {
        std::cout << i << '\n';
    }
};
 
int main()
{
    // store a free function
    std::function<void(int)> f_display = print_num;
    f_display(-9);
 
    // store a lambda
    std::function<void()> f_display_42 = []() { print_num(42); };
    f_display_42();
 
    // store the result of a call to std::bind
    std::function<void()> f_display_31337 = std::bind(print_num, 31337);
    f_display_31337();
 
    // store a call to a member function
    std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
    const Foo foo(314159);
    f_add_display(foo, 1);
    f_add_display(314159, 1);
 
    // store a call to a data member accessor
    std::function<int(Foo const&)> f_num = &Foo::num_;
    std::cout << "num_: " << f_num(foo) << '\n';
 
    // store a call to a member function and object
    using std::placeholders::_1;
    std::function<void(int)> f_add_display2 = std::bind( &Foo::print_add, foo, _1 );
    f_add_display2(2);
 
    // store a call to a member function and object ptr
    std::function<void(int)> f_add_display3 = std::bind( &Foo::print_add, &foo, _1 );
    f_add_display3(3);
 
    // store a call to a function object
    std::function<void(int)> f_display_obj = PrintNum();
    f_display_obj(18);
}

代碼來自：
https://blog.csdn.net/Poo_Chai/article/details/90066739
作者： Poo_Chai
           

關于tr1::function 和 tr1::bind更詳細解釋，可以參考：

https://blog.csdn.net/chdhust/article/details/8006601

（3）古典的strategy模式

class GameCharacter;
class HealthCalFunc
{
	public:
	virtual int calc(const GameCharacter& gc) const
	{
	}
}
HealthCalFunc defaultHealthcalc;
class GameCharacter
{
 explicit GameCharacter(HealthCalFunc *phcf = &defaultHealthcalc) //多态的出現點
 :pHeathCalc(phcf)
 {
 }
 int healthValue
 {
 	return pHealthCalc->calc(*this); //多态的出現點
 }
 private:
 HealthCalFunc  pHeathCalc;
}
           

條款 36 絕不重新定義繼承而來的non-virtual函數

注意不要在子類中重新定義繼承而來的non-virtual函數，如果定義了，子類中的該函數的版本會掩蓋原來父類中的版本，這樣的話，如果使用對象指針來調用成員函數，則調用子類版本還是父類版本取決于一開始定義的指針是什麼類型，因為non-virtual是靜态綁定的。

條款 37 絕不重新定義繼承而來的預設參數值

virtual函數是動态綁定

而預設參數是靜态綁定

靜态類型是在程式聲明時所采用的的類型

動态類型是指“目前所指對象的類型”

class shape
{
public:
	enum shapeColor {red,green,blue};
	virtual void draw(shapeColor color = red) const = 0;
}
class rectangle :public shape
{
public:
	//注意，賦予不同的預設值，這真糟糕
	virtual void draw(shapeColor color = green) const;
}

class circle :public shape
{
public:
	virtual void draw(shapeColor color ) const;
	//注意，當以對象的方式調用此函數的時候，一定要指定參數，但是要是使用指針調用的話，不用指定參數值
	//因為動态綁定下這個函數會從其base繼承預設的參數值
}
           

偏要繼承預設值的方法：

class shape
{
public:
	enum shapeColor {red,green,blue};
	void draw(shapeColor color = red) const
	{
		doDraw(color);
	}
private：
	virtual void doDraw(shapeColor color) const = 0;
}

class rectangle :public shape
{
public:
private:
	virtual void draw(shapeColor color ) const;
}
           

這樣可以是繼承體系中的參數為預設值red。