Head First 設計模式（一）策略模式（strategy pattern） C++實現

原創

ACLegend

2020-02-22 18:54

設計原則：1、找出應用中可能需要變化之處，把他們獨立出來，不要和那些不需要變化的代碼混在一起

2、針對接口編程，而不是針對實現編程

3、多用組合，少用繼承

策略模式定義了算法族，分別封裝起來，讓他們之間可以相互替換，此模式讓算法的變化獨立於使用算法的客戶

類圖：

C++ 代碼如下

下載：http://download.csdn.net/detail/lingyunjinzhu/5165455點擊打開鏈接

//Duck.h

#pragma once
#include "FlyBehavior.h"
#include "QuackBehavior.h"
class Duck
{
public:
        Duck(void);
        ~Duck(void);
        FlyBehavior*flyBehavior;
    QuackBehavior*quackBehavior;
        void swim();
    virtual voiddisplay();
    voidPerformQuack();
    voidPerformFly();
    voidsetFlyBehavior(FlyBehavior *fly);
    voidsetQuackBehavior(QuackBehavior *QuackBehavior);
};

//Duck.cpp
#include "stdafx.h"
#include "Duck.h"
Duck::Duck(void)
{
}
Duck::~Duck(void)
{
}
void Duck::display()
{

        std::cout<<"I'ma duck!"<<std::endl;

}


void Duck::PerformFly()
{
        flyBehavior->fly();
}
void Duck::PerformQuack()
{
        quackBehavior->quack();
}


void Duck::setFlyBehavior(FlyBehavior *fb)
{
       flyBehavior=fb;
}

void Duck::setQuackBehavior(QuackBehavior *qb)
{
        quackBehavior= qb;
}

//DecoyDuck.h
#pragma once
#include "duck.h"
class DecoyDuck :
        public Duck
{
public:
        DecoyDuck(void);

        ~DecoyDuck(void);

        voiddisplay();

};


//DecoyDuck.cpp
#include "stdafx.h"
#include "DecoyDuck.h"

DecoyDuck::DecoyDuck(void)
{
        flyBehavior=newFlyNoWay();
        quackBehavior=newQuack();
}


DecoyDuck::~DecoyDuck(void)

{

}

void DecoyDuck::display()

{

   std::cout<<"I'm a decoy duck!"<<std::endl;

}

//MallarDuck.h
#pragma once
#include "duck.h"
class MallarDuck :
        public Duck
{
public:

       MallarDuck(void);

        ~MallarDuck(void);
        voiddisplay();
};

 
////MallarDuck.cpp

#include "stdafx.h"
#include "MallarDuck.h"

MallarDuck::MallarDuck(void)
{
        flyBehavior=newFlyWithWings();
        quackBehavior=newQuack();
}

MallarDuck::~MallarDuck(void)
{
}
void MallarDuck::display()
{
   std::cout<<"I'm a mallar Duck!"<<std::endl;
}

//ModelDuck .h
#pragma once
#include "duck.h"
class ModelDuck :
        public Duck
{
public:
        ModelDuck(void);
        ~ModelDuck(void);
        voiddisplay();
};
//ModelDuck .cpp
#include "stdafx.h"
#include "ModelDuck.h"
ModelDuck::ModelDuck(void)
{
        flyBehavior=newFlyNoWay();
        quackBehavior=new Quack();
}

ModelDuck::~ModelDuck(void)
{
}
void ModelDuck::display()
{
        std::cout<<"I'ma model duck!"<<std::endl;
}

//RedheadDuck.h
#pragma once
#include "duck.h"
class RedheadDuck :
        public Duck
{
public:
        RedheadDuck(void);
        ~RedheadDuck(void);
        voiddisplay();
};
//RedheadDuck.cpp
#include "stdafx.h"
#include "RedheadDuck.h"
RedheadDuck::RedheadDuck(void)
{
        flyBehavior=newFlyWithWings();
        quackBehavior=newQuack();
}
 
RedheadDuck::~RedheadDuck(void)
{
}
void RedheadDuck::display()
{
   std::cout<<"I'm a redhead duck!"<<std::endl;
}

 //RubberDuck.h
#pragma once
#include "duck.h"
class RubberDuck :
        public Duck
{
public:
        RubberDuck(void);
        ~RubberDuck(void);
        voiddisplay();
};
 //RubberDuck.cpp
#include "stdafx.h"
#include "RubberDuck.h"
RubberDuck::RubberDuck(void)
{
        flyBehavior=newFlyNoWay();
        quackBehavior=newQuack();    
}
RubberDuck::~RubberDuck(void)
{
}
void RubberDuck::display()
{
   std::cout<<"I'm a rubber Duck!"<<std::endl;
}
// QuackBehavior.h
#pragma once
class QuackBehavior
{
public:
        QuackBehavior(void);
        ~QuackBehavior(void);
        virtual voidquack()=0;
};

// QuackBehavior.cpp
#include "stdafx.h"
#include "QuackBehavior.h"
QuackBehavior::QuackBehavior(void)
{
}

QuackBehavior::~QuackBehavior(void)
{
}
//MuteQuack.h
#pragma once
#include "quackbehavior.h"
class MuteQuack :
        publicQuackBehavior
{
public:
        MuteQuack(void);
        ~MuteQuack(void);
        voidquack();
};

//MuteQuack.cpp
#include "stdafx.h"
#include "MuteQuack.h"
MuteQuack::MuteQuack(void)
{
}
MuteQuack::~MuteQuack(void)
{
}
void MuteQuack::quack()
{
   std::cout<<"<< Silence >>"<<std::endl;
}

//Squeak.h
#pragma once
#include "quackbehavior.h"
class Squeak :
        publicQuackBehavior
{
public:
        Squeak(void);
        ~Squeak(void);
        voidquack();
};

////Squeak.cpp
#include "stdafx.h"
#include "Squeak.h"

Squeak::Squeak(void)
{
} 
Squeak::~Squeak(void)
{
}

void Squeak::quack()
{
   std::cout<<"Squack"<<std::endl;
}

//Quack.h
#pragma once
#include "quackbehavior.h"
class Quack :
        publicQuackBehavior
{
public:
        Quack(void);
        ~Quack(void);
        voidquack();
};

////Quack.cpp

#include "stdafx.h"
#include "Quack.h"
Quack::Quack(void)
{
}
Quack::~Quack(void)
{
}
void Quack::quack()
{
  std::cout<<"Quack"<<std::endl;
}

//FlyBehavior.h
#pragma once
class FlyBehavior
{
public:
        FlyBehavior(void);
        ~FlyBehavior(void);
        virtual voidfly()=0;
};
////FlyBehavior.cpp
#include "stdafx.h"
#include "FlyBehavior.h"
FlyBehavior::FlyBehavior(void)
{
}
FlyBehavior::~FlyBehavior(void)
{
}

//FlyWithWings.h
#pragma once
#include "flybehavior.h"
class FlyWithWings :
        publicFlyBehavior
{
public:
        FlyWithWings(void);
        ~FlyWithWings(void);
        void fly();
};
////FlyWithWings.cpp
#include "stdafx.h"
#include "FlyWithWings.h"
FlyWithWings::FlyWithWings(void)
{
}
FlyWithWings::~FlyWithWings(void)
{
}
void FlyWithWings::fly()
{
   std::cout<<"I'm flying!"<<std::endl;
}

//FlyNoWay.h
#pragma once
#include "flybehavior.h"
class FlyNoWay :
        publicFlyBehavior
{
public:
        FlyNoWay(void);
        ~FlyNoWay(void);
        void fly();
};
//FlyNoWay.cpp
#include "stdafx.h"
#include "FlyNoWay.h"
FlyNoWay::FlyNoWay(void)
{
}
FlyNoWay::~FlyNoWay(void)
{
}
void FlyNoWay::fly()
{
  std::cout<<"I can't fly!"<<std::endl;
}

//FlyRocketPowered.h
#pragma once
#include "flybehavior.h"
class FlyRocketPowered :
        publicFlyBehavior
{
public:
        FlyRocketPowered(void);
        ~FlyRocketPowered(void);
        void fly();
};
//FlyRocketPowered.h
#include "stdafx.h"
#include "FlyRocketPowered.h"
FlyRocketPowered::FlyRocketPowered(void)
{
}
FlyRocketPowered::~FlyRocketPowered(void)
{
}
void FlyRocketPowered::fly()
{
        std::cout<<"I'mflying with a rocked!"<<std::endl;
}

測試的主函數：

// TestDuck.cpp : 定義控制檯應用程序的入口點。
//

#include "stdafx.h"
int main(int argc, _TCHAR* argv[])
{
        Duck*mallard= new MallarDuck();
        mallard->PerformFly();
        mallard->PerformQuack();
        mallard->display();
        Duck *model= new ModelDuck();
        model->PerformFly();

        model->setFlyBehavior(newFlyRocketPowered());
        model->PerformFly();
        return 0;
}

運行結果