策略模式是指有一定行動內容的相對穩定的策略名稱。

—抽象策略角色： 策略類，通常由一個介面或者抽象類實現。

—具體策略角色：包裝了相關的演算法和行為。

—環境角色：持有一個策略類的引用，最終給客戶端呼叫。

應用場景：

1、 多個類只區別在表現行為不同，可以使用Strategy模式，在執行時動態選擇具體要執行的行為。

2、 需要在不同情況下使用不同的策略(演算法)，或者策略還可能在未來用其它方式來實現。

3、 對客戶隱藏具體策略(演算法)的實現細節，彼此完全獨立。

#include <iostream>

using namespace std;

class FLYBehavior
{
public:
	virtual ~FLYBehavior() {}
	virtual void fly() = 0;
};

class FLYWithWings : public FLYBehavior
{
public:
	~FLYWithWings() {}
	void fly() override
	{
		cout << "I can fly!" << endl;
	}
};
class FLYNoWay : public FLYBehavior
{
public:
	~FLYNoWay() {}

        void fly() override
        {
                cout << "I can not fly!" << endl;
        }
};

class SWIMBehavior
{
public:
	virtual ~SWIMBehavior() {}
	virtual void swim() = 0;
};

class SWIMWithWings : public SWIMBehavior
{
public:
	~SWIMWithWings() {}
        void swim() override
        {
                cout << "I can swim!" << endl;
        }
};
class SWIMNoWay : public SWIMBehavior
{
public: 
	~SWIMNoWay() {}
        void swim() override
        {
                cout << "I can not swim!" << endl;
        }
};

class Dunk
{
private:
	int color;
	int age;
	int weight;
public:
        FLYBehavior *flyBehavior;
        SWIMBehavior *swimBehavior;
	Dunk(int c = 0):color(c)
 	{
	}
	virtual ~Dunk() 
	{
		cout << "Dunk destructor" << endl;
		if (NULL != flyBehavior)
		{
			cout << "delete flyBehavior" << endl;
			delete flyBehavior;
		}
		if (NULL != swimBehavior)
		{
			cout << "delete swimBehavior" << endl;
			delete swimBehavior;
		}
	}

	void set_color(int _c) { color = _c; }
	void set_age(int _a) { age = _a; }
	void set_weight(int _w) { weight = _w; }

	const char* get_color() const
	{
		if (color == 1)
		{
			return "red";
		}
		else if (color == 2)
		{
			return "blue";
		}
	}
	int get_age() const { return age; }
	int get_weight() const { return weight; }

	virtual void display() = 0;

	void print()
	{
		display();
		if (flyBehavior != NULL)
		{
			flyBehavior->fly();
		}
		if (swimBehavior != NULL)
		{
			swimBehavior->swim();
		}
	}
};

class redDunk : public Dunk
{
public:
	redDunk() : Dunk(1)
	{
		flyBehavior = new FLYWithWings();
		swimBehavior = new SWIMNoWay();
	}
	~redDunk()
	{
		cout << "red dunk destructor" << endl;
	}
	void display() override;
};
class blueDunk : public Dunk
{
public: 
	blueDunk() : Dunk(2)
	{
		flyBehavior = new FLYNoWay();
		swimBehavior = new SWIMWithWings();
	}
	~blueDunk()
	{
		cout << "blue dunk destructor" << endl;
	}
        void display() override;
};

void redDunk::display()
{
	cout << "I'm red dunk" << endl;
}
void blueDunk::display()
{
        cout << "I'm blue dunk" << endl;
}

int main()
{
	Dunk *red = new redDunk();
	Dunk *blue = new blueDunk();

	red->print();
        blue->print();

	delete red;
	delete blue;
	return 0;
}