策略模式

策略模式:定义了算法族,分别封装起来.让他们之间可以互相替换.此模式让算法的变化独立于使用算法的客户。

//main-test

// Duck.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include "Duck.h"

int main()
{
	CMallardDuck duck;

	duck.Display();
	duck.Fly();
	duck.Quack();
	duck.Swim();

	return 0;
}

//fly interface
#pragma once

class IFly
{
public:
	IFly(void);
	virtual ~IFly(void);

public:
	virtual void Fly() = 0;
};

//CFlyWithWings
class CFlyWithWings:public IFly
{
public:
	CFlyWithWings();
	~CFlyWithWings();

public:
	virtual void Fly();
};

//CFlyNoWay
class CFlyNoWay:public IFly
{
public:
	CFlyNoWay();
	~CFlyNoWay();

public:
	virtual void Fly();
};

#include "stdafx.h"
#include "Fly.h"

IFly::IFly(void)
{
}

IFly::~IFly(void)
{
}

//CFlyWithWings
CFlyWithWings::CFlyWithWings(void)
{
}

CFlyWithWings::~CFlyWithWings(void)
{
}

void CFlyWithWings::Fly()
{
	cout << "I'm flying" << endl;
}

//CFlyNoWay
CFlyNoWay::CFlyNoWay(void)
{
}

CFlyNoWay::~CFlyNoWay(void)
{
}

void CFlyNoWay::Fly()
{
	cout << "I can't flying" << endl;
}

//quake interface
#pragma once

//IQuack
class IQuack
{
public:
	IQuack(void);
	virtual ~IQuack(void);

public:
	virtual void Quack() = 0;
};

//CQuack
class CQuack:public IQuack
{
public:
	CQuack();
	~CQuack();

public:
	virtual void Quack();
};

//CMuteQuack
class CMuteQuack:public IQuack
{
public:
	CMuteQuack();
	~CMuteQuack();

public:
	virtual void Quack();
};

//CSqueak
class CSqueak:public IQuack
{
public:
	CSqueak();
	~CSqueak();

public:
	virtual void Quack();
};


#include "stdafx.h"
#include "Quack.h"

IQuack::IQuack(void)
{
}

IQuack::~IQuack(void)
{
}

//CQuack
CQuack::CQuack(void)
{
}

CQuack::~CQuack(void)
{
}

void CQuack::Quack()
{
	cout << "Quack" << endl;
}

//CMuteQuack
CMuteQuack::CMuteQuack(void)
{
}

CMuteQuack::~CMuteQuack(void)
{
}

void CMuteQuack::Quack()
{
	cout << "<< Slience >>" << endl;
}

//CSqueak
CSqueak::CSqueak(void)
{
}

CSqueak::~CSqueak(void)
{
}

void CSqueak::Quack()
{
	cout << "Squeak" << endl;
}

//duck
#pragma once
#include "Fly.h"
#include "Quack.h"

class IDuck
{
public:
	IDuck();
	virtual ~IDuck(void);

public:
	virtual void Display() = 0;

public:
	void Fly();
	void Quack();
	void Swim();

	void SetBehavior(IFly* pFly, IQuack* pQuack);

protected:
	IFly*	m_pFly;
	IQuack*	m_pQuack;
};

//CMallardDuck
class CMallardDuck:public IDuck
{
public:
	CMallardDuck();
	~CMallardDuck();

public:
	virtual void Display();
};

#include "stdafx.h"
#include "duck.h"

IDuck::IDuck()
{
	m_pFly = NULL;
	m_pQuack = NULL;
}

IDuck::~IDuck(void)
{
}

void IDuck::SetBehavior(IFly* pFly, IQuack* pQuack)
{
	m_pFly = pFly;
	m_pQuack = pQuack;
}

void IDuck::Fly()
{
	if (NULL == m_pFly)
	{
		cout << "no fly implement..." << endl;
	}

	m_pFly->Fly();
}

void IDuck::Quack()
{
	if (NULL == m_pQuack)
	{
		cout << "no quack implement..." << endl;
	}

	m_pQuack->Quack();
}

void IDuck::Swim()
{
	cout << "All duck can swim, even decoys!" << endl;
}

//CMallardDuck
CMallardDuck::CMallardDuck()
{
	IFly* pFly = new CFlyWithWings;
	IQuack* pQuack = new CSqueak;

	SetBehavior(pFly, pQuack);
}

CMallardDuck::~CMallardDuck()
{
	if (NULL != m_pFly)
	{
		delete m_pFly;
		m_pFly = NULL;
	}

	if (NULL != m_pQuack)
	{
		delete m_pQuack;
		m_pQuack = NULL;
	}
}

void CMallardDuck::Display()
{
	cout << "I am Mallard Duck!" << endl;
}