#include "fly_behavior.h"
#include "speak_behavior.h"

#ifndef DUCK_H
#define DUCK_H

abstract class Duck
{
public:
	Duck();
	~Duck();
	void PerformFly();
	void PerformSpeak();

protected:
	FlyBehavior * _fly_behavior;
	SpeakBehavior * _speak_behavior;
};

#endif

#include "duck.h"

Duck::Duck()
{

}

Duck::~Duck()
{

}

void Duck::PerformFly()
{
	this->_fly_behavior->Fly();
}

void Duck::PerformSpeak()
{
	this->_speak_behavior->Speak();
}

#ifndef FLY_BEHAVIOR_H
#define FLY_BEHAVIOR_H

class FlyBehavior
{
public:
	void Fly();
};

#endif

#include "fly_behavior.h"

void FlyBehavior::Fly()
{

}

#ifndef SPEAK_BEHAVIOR_H
#define SPEAK_BEHAVIOR_H

class SpeakBehavior
{
public:
	void Speak();
};

#endif

#include "speak_behavior.h"

void SpeakBehavior::Speak()
{

}

SpeakBehavior * _speak_behavior = new Squeak()

#include "duck.h"

#ifndef TOY_DUCK_H
#define TOY_DUCK_H

class ToyDuck: public Duck
{
public:
	ToyDuck();
	~ToyDuck();
};

#endif

#include "toy_duck.h"
#include "not_fly.h"
#include "squeak.h"

ToyDuck::ToyDuck()
{
	this->_fly_behavior = new NotFly();
	this->_speak_behavior = new Squeak();
}

ToyDuck::~ToyDuck()
{

}

#include <iostream>
#include <conio.h>

#include "toy_duck.h"

void main()
{
	std::cout << "DUCK SIMULATOR" << std::endl;
	
	ToyDuck * toy_duck_object = new ToyDuck();

	toy_duck_object->PerformFly();
	toy_duck_object->PerformSpeak();
	
	_getch();
}

#include "fly_behavior.h"#include "speak_behavior.h"#ifndef DUCK_H#define DUCK_H// "Duck" is not abstractclass Duck{public:        // pass the behavior in the ctor - favour composition over inheritance	Duck(FlyBehavior *, SpeakBehavior*);	~Duck();	void PerformFly();	void PerformSpeak();protected:	FlyBehavior * _fly_behavior;	SpeakBehavior * _speak_behavior;};#endif

#include "duck.h"// use proper constructor initialisersDuck::Duck(FlyBehavior * fly, SpeakBehavior * speak): _fly_behavior(fly),  _speak_behavior(speak){}// remember to delete what you allocateDuck::~Duck(){    delete _fly_behavior;    delete _speak_behavior;}void Duck::PerformFly(){    _fly_behavior->Fly();}void Duck::PerformSpeak(){    _speak_behavior->Speak();}

#include "duck.h"#include "not_fly.h"#include "squeak.h"namespace{    Duck * MakeToyDuck()    {        return new Duck(new NoFly, new Squeak);    }}// "main" should return "int"int main(){	std::cout << "DUCK SIMULATOR" << std::endl;	        // prefer a factory method over inheritance	Duck * toy_duck_object = MakeToyDuck();	toy_duck_object->PerformFly();	toy_duck_object->PerformSpeak();	        delete toy_duck_object;}

#ifndef DUCK_H#define DUCK_H// "Duck" is an abstract base classclass Duck{public:        // note the virtual destructor	virtual ~Duck();	        void PerformFly();	void PerformSpeak();protected:        // make the ctor protected, i.e. "Duck" cannot be instanciated        Duck(FlyBehavior *, SpeakBehavior *);	FlyBehavior * _fly_behavior;	SpeakBehavior * _speak_behavior;};#endif

#include "duck.h"Duck::Duck(FlyBehavior * fly, SpeakBehavior * speak): _fly_behavior(fly),  _speak_behavior(speak){}Duck::~Duck(){    delete _fly_behavior;    delete _speak_behavior;}void Duck::PerformFly(){    _fly_behavior->Fly();}void Duck::PerformSpeak(){    _speak_behavior->Speak();}

include "duck.h"#ifndef TOY_DUCK_H#define TOY_DUCK_H// the dtor is not necessary, it's already defined in "Duck"class ToyDuck: public Duck{public:        // the ctor is public and omits the behavior arguments	ToyDuck();};#endif

#include "toy_duck.h"#include "not_fly.h"#include "squeak.h"// the ctor invokes the base class' ctor with the appropriate argumentsToyDuck::ToyDuck() : Duck(new NotFly, new Squeak){}

#include <iostream>#include "toy_duck.h"// "main" stays the sameint main(){	std::cout << "DUCK SIMULATOR" << std::endl;	        // note that you can use both "Duck" and "ToyDuck" as your        / object's type. prefer the base class.	Duck * toy_duck_object = new ToyDuck;	toy_duck_object->PerformFly();	toy_duck_object->PerformSpeak();        delete toy_duck_object;}

#ifndef FLY_BEHAVIOR_H#define FLY_BEHAVIOR_Hclass FlyBehavior{public:        // the "virtual" is required so that calls to the interface        // will dispatch to the derived class. the " = 0" denotes        // an abstract method, i.e. FlyBehavior::Fly() cannot be called        // and FlyBehavoir cannot be instanciated.        // the brackets are the default implementaion, which may be called        // by derived classes using "FlyBehavior::Fly()"	virtual void Fly() = 0 { }};/*   Example:   class NoFly : public FlyBehavior   {        // implement "Fly" by just calling the default implementation.        // only works if a default implementation exists, though.        void Fly()        {            FlyBehavior::Fly();        }   };*/#endif