Head first design patterns c++实现， strategy

看了Head first design patterns，就自己试着用c++实现了一下，例子都和书上的一样，照猫画虎，不知道行不行 ：）

//flybehavior.h

//strategy

#ifndef FLYBEHAVIOR_H___
#define FLYBEHAVIOR_H___

class FlyBehavior {
public:
 virtual void Fly() = 0;
};

#endif 

 

//canfly.h

.//concrete strategy

#ifndef CANFLY_H__
#define CANFLY_H__

#include "flybehavior.h"
#include <iostream>
using namespace std;

class CanFly : public FlyBehavior {
public:
 void Fly() { cout << "I can fly/n";}
};

#endif

//nowayfly.h

//concrete strategy

#ifndef NOWAYFLY_H__
#define NOWAYFLY_H__

#include "flybehavior.h"
#include <iostream>
using namespace std;

class NoWayFly : public FlyBehavior {
public:
 void Fly()
 { cout << "I cannot fly/n"; }
};

#endif

//quackbehavior.h

//strategy

#ifndef QUACKBEHAVIOR_H__
#define QUACKBEHAVIOR_H__

class QuackBehavior {
public:
 virtual void Quack() = 0;
};

#endif

//canquack.h

//concrete strategy

#ifndef CANQUACK_H__
#define CANQUACK_H__

#include "quackbehavior.h"
#include <iostream>
using namespace std;

class CanQuack : public QuackBehavior {
public:
 void Quack() { cout << "I can quack, Quack~Quack~~/n"; }
};

#endif

//noquack.h

//concrete strategy

#ifndef NOQUACK_H__
#define NOQUACK_H__

#include "quackbehavior.h"
#include <iostream>
using namespace std;

class NoQuack : public QuackBehavior {
public:
 void Quack()
 { cout << "I cannot quack/n"; }
};

#endif

//squeak.h

//concrete strategy

#ifndef SQUEAK_H__
#define SQUEAK_H__

#include "quackbehavior.h"
#include <iostream>
using namespace std;

class Squeak : public QuackBehavior {
public:
 void Quack() { cout << "I cannot Quack, but squeak/n"; }
};

#endif

#ifndef DUCK_H__
#define DUCK_H__

//duck.h

//context

#include "flybehavior.h"
#include "quackbehavior.h"
#include <iostream>
using namespace std;

class Duck {
public:
 Duck(){}
 virtual ~Duck(){}
 virtual void Display() = 0;
 virtual void performFly(){ flyBehavior->Fly();}
 virtual void performQuack() { quackBehavior->Quack(); }
 void Swim() { cout << "I can swim" << endl; }

protected:
 FlyBehavior* flyBehavior;
 QuackBehavior* quackBehavior;

private:
 Duck(const Duck& d){}
 Duck& operator=(const Duck& d){}
};

#endif

//decoyduck.h

//concrete context

#ifndef DECOYDUCK__H___
#define DECOYDUCK__H__

#include "duck.h"

class DecoyDuck : public Duck {
public:
 DecoyDuck();
 void Display();

private:
 DecoyDuck(const DecoyDuck& dd){}
 DecoyDuck& operator=(const DecoyDuck& dd){}
};

#endif

//decoyduck.cpp

#include "decoyduck.h"
#include "nowayfly.h"
#include "noquack.h"
#include <iostream>
using namespace std;

DecoyDuck::DecoyDuck()
{
 flyBehavior = new NoWayFly();
 quackBehavior = new NoQuack();
}

void DecoyDuck::Display()
{
 cout << "I am a DecoyDuck"  << endl;
}

//mallardduck.h

//concrete context

#ifndef MALLARDDUCK_H__
#define MALLARDDUCK_H__

#include "duck.h"

class MallardDuck : public Duck{
public:
 MallardDuck();
 void Display();

private:
 MallardDuck(const MallardDuck& md){}
 MallardDuck& operator=(const MallardDuck& md){}
};

#endif

//mallardduck.cpp

#include "mallardduck.h"
#include "canfly.h"
#include "canquack.h"
#include <iostream>
using namespace std;

MallardDuck::MallardDuck()
{
 flyBehavior = new CanFly();
 quackBehavior = new CanQuack();
}

void MallardDuck::Display()
{
 cout << "I am Mallard Duck/n";
}

//redheadduck.h

//concrete context

#ifndef REDHEADDUCK_H__
#define REDHEADDUCK_H__

#include "duck.h"

class RedHeadDuck : public Duck {
public:
 RedHeadDuck();
 void Display();

private:
 RedHeadDuck(const RedHeadDuck& rd){}
 RedHeadDuck& operator=(const RedHeadDuck& rd){}
};
 
#endif

//redheadduck.cpp

#include "redheadduck.h"
#include "canfly.h"
#include "canquack.h"
#include <iostream>
using namespace std;

RedHeadDuck::RedHeadDuck()
{
 flyBehavior = new CanFly();
 quackBehavior = new CanQuack();
}

void RedHeadDuck::Display()
{
 cout << "I am Red Head Duck/n";
}

//rubberduck.h

//concrete context

#ifndef RUBBERDUCK_H__
#define RUBBERDUCK_H__

#include "duck.h"

class RubberDuck : public Duck {
public:
 RubberDuck();
 void Display();

private:
 RubberDuck(const RubberDuck& rd){}
 RubberDuck& operator=(const RubberDuck& rd){}
};

#endif

//rubberduck.cpp

#include "rubberduck.h"
#include "nowayfly.h"
#include "squeak.h"
#include <iostream>
using namespace std;

RubberDuck::RubberDuck()
{
 flyBehavior = new NoWayFly();
 quackBehavior = new Squeak();
}

void RubberDuck::Display()
{
 cout << "I am a Rubber Duck" << endl;
}

//main.cpp

#include "duck.h"
#include "decoyduck.h"
#include "redheadduck.h"
#include "rubberduck.h"
#include "mallardduck.h"

void DisplayDuck(Duck* d);

int main()
{
 Duck* decoyduck = new DecoyDuck();
 Duck* redheadduck = new RedHeadDuck();
 Duck* rubberduck = new RubberDuck();
 Duck* mallardduck = new MallardDuck();

 DisplayDuck(decoyduck);
 DisplayDuck(redheadduck);
 DisplayDuck(rubberduck);
 DisplayDuck(mallardduck);

 return 0;
}

void DisplayDuck(Duck* d)
{ 
 d->Display();
 d->performFly();
 d->performQuack();
 d->Swim();
}