Class Client: public Context

{ public:

    void useStrategy(void)

    {

              operation->use();

    }

    void setStrategy(Strategy* o)

    {

              operation = o;

    }

};

int main(int /*argc*/, char* /*argv*/[])

{

    Client customClient;

    Strategy_1 str1;

    Strategy_2 str2;

    Strategy_3 str3;

    customClient.setStrategy(&str1);

    customClient.useStrategy();

    customClient.setStrategy(&str2);

    customClient.useStrategy();

    customClient.setStrategy(&str3);

    customClient.useStrategy();

    return 0;

}

Еще раз - Назначение паттерна Strategy

Существуют системы, поведение которых может определяться согласно одному алгоритму из некоторого семейства.

Все алгоритмы этого семейства являются родственными: предназначены для решения общих задач, имеют одинаковый интерфейс для использования и отличаются только реализацией (поведением).

Пользователь, предварительно настроив программу на нужный алгоритм (выбрав стратегию), получает ожидаемый результат.

Как пример, - приложение, предназначенное для компрессии файлов, использует один из доступных алгоритмов: zip, arj или rar.

Объектно-ориентированный дизайн такой программы может быть построен на идее использования полиморфизма. В результате получаем набор родственных классов с общим интерфейсом и различными реализациями алгоритмов.

#include <iostream>

#include <string>

// Иерархия классов, определяющая алгоритмы сжатия файлов

Class Compression

{

public:

virtual ~Compression() {}

virtual void compress(const string & file) = 0;

};

class ZIP_Compression: public Compression

{

public:

void compress(const string & file) {

cout << "ZIP compression" << endl;

}

};

class ARJ_Compression: public Compression

{

public:

void compress(const string & file) {

cout << "ARJ compression" << endl;

}

};

class RAR_Compression: public Compression

{

public:

void compress(const string & file) {

cout << "RAR compression" << endl;

}

};

// Класс для использования

Class Compressor

{

public:

Compressor(Compression* comp): p(comp) {}

~Compressor() { delete p; }

void compress(const string & file) {

p->compress(file);

}

private:

Compression* p;

};

int main()

{

Compressor* p = new Compressor(new ZIP_Compression);

p->compress("file.txt");

delete p;

return 0;

}

Еще пример.

 

#include <iostream>

#include <cstdlib>

 

#include "strategy.h"

#include "header/concrete_output1.h"

#include "header/concrete_output2.h"

#include "printer.h"

 

using namespace std;

 

Int main()

{

Printer some_printer;

ConcreteOutput1 out1;

ConcreteOutput2 out2;

 

some_printer.set_output_method(&out1);

some_printer.print();

 

some_printer.set_output_method(&out2);

some_printer.print();

 

system("pause");

return 0;

}

// strategy.h

 

#ifndef _STRATEGY_H_

#define _STRATEGY_H_

 

Class StrategyPrint

{ public:

StrategyPrint();

~StrategyPrint();

virtual void output() = 0;

};

 #endif

 

// strategy.cpp

 

#include "strategy.h"

 

StrategyPrint::StrategyPrint()

{ };

 

StrategyPrint::~StrategyPrint()

{ };

// concrete_output1.h

 #ifndef _CONCRETE_OUTPUT1_H_

#define _CONCRETE_OUTPUT1_H_

 

#include <iostream>

#include "strategy.h"

 class ConcreteOutput1: public StrategyPrint

{

public:

ConcreteOutput1();

~ConcreteOutput1();

void output();

};

#endif

 

// concrete_output1.cpp

#include "concrete_output1.h"

ConcreteOutput1::ConcreteOutput1()

{ }

 

ConcreteOutput1::~ConcreteOutput1()

{ }

 

Void ConcreteOutput1::output()

{

std::cout << "You choose 1st strategy\n";

}

// concrete_output2.h

 

#ifndef _CONCRETE_OUTPUT2_H_

#define _CONCRETE_OUTPUT2_H_

 

#include <iostream>

#include "strategy.h"

 

Class ConcreteOutput2: public StrategyPrint

{ public:

ConcreteOutput2();

~ConcreteOutput2();

void output();

};

#endif

 

// concrete_output2.cpp

#include "header/concrete_output2.h"

 

ConcreteOutput2::ConcreteOutput2()

{ }

 

ConcreteOutput2::~ConcreteOutput2()

{ }