看了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();
}