// Purpose. Strategy #include <iostream.h>
// #include <stdlib.h>
// Discussion. The class Stat has a #include <time.h>
// Bubble sort algorithm hard-wired in
// it. It would be nice if the choice class SortImp;
// of algorithm were configurable.
// The Strategy pattern suggests "de- class Stat {
// fine a family of algo's, encapsu- public:
// late each one, and make them inter- Stat();
// changeable" via an abstract base void upGrade();
// class. void downGrade();
void readVector( int[], int );
class Stat { /* Bubble sort */ int getMin() { return min_; }
public: int getMax() { return max_; }
void readVector( int v[], int n ) { int getMed() { return med_; }
sort_( v, n ); private:
min_ = v[0]; max_ = v[n-1]; int min_, max_, med_;
med_ = v[n/2]; } SortImp* imp_;
int getMin() { return min_; } };
int getMax() { return max_; }
int getMed() { return med_; } class SortImp { public:
private: virtual void sort( int[], int ) = 0;
int min_, max_, med_; };
void sort_( int v[], int n ) {
for (int i=n-1; i > 0; i--) class SortBubble : public SortImp {
for (int j=0; j < i; j++) public:
if (v[j] > v[j+1]) { void sort( int v[], int n );
int t = v[j]; };
v[j] = v[j+1];
v[j+1] = t; } class SortShell : public SortImp {
cout << "Bubble: "; public:
for (int k=0; k < n; k++) void sort( int v[], int n );
cout << v[k] << ' '; };
cout << endl;
} #include "strategy2.inc"
};
Stat::Stat() { imp_ = new SortBubble; }
void main( void ) void Stat::upGrade() { delete imp_;
{ imp_ = new SortShell; }
const int NUM = 9; void Stat::downGrade() { delete imp_;
int array[NUM]; imp_ = new SortBubble; }
time_t t; void Stat::readVector(int v[], int n) {
srand((unsigned) time(&t)); imp_->sort( v, n );
cout << "Vector: "; min_ = v[0]; max_ = v[n-1];
for (int i=0; i < NUM; i++) { med_ = v[n/2]; }
array[i] = rand() % 9 + 1;
cout << array[i] << ' '; } void main( void )
cout << endl; {
const int NUM = 9;
Stat obj; int array[NUM];
obj.readVector( array, NUM ); time_t t;
cout << "min is " << obj.getMin() srand((unsigned) time(&t));
<< ", max is " << obj.getMax() cout << "Vector: ";
<< ", median is " << obj.getMed() for (int i=0; i < NUM; i++) {
<< endl; array[i] = rand() % 9 + 1;
} cout << array[i] << ' '; }
cout << endl;
/***** current implementation *****/
// Vector: 6 9 9 8 6 5 7 9 2 Stat obj;
// Bubble: 2 5 6 6 7 8 9 9 9 obj.upGrade();
// min is 2, max is 9, median is 7 obj.readVector( array, NUM );
/*** an upgraded implementation ***/ cout << "min is " << obj.getMin()
// Vector: 4 8 6 4 6 7 4 7 2 << ", max is " << obj.getMax()
// Shell: 2 4 4 4 6 6 7 7 8 << ", median is " << obj.getMed()
// min is 2, max is 8, median is 6 << endl;
}


// Purpose. Strategy (template #include <iostream>
// approach) #include <cstdlib>
// A template can be used to configure #include <ctime>
// a client with a Strategy. This using namespace std;
// technique is appropriate if: 1) the
// Strategy can be selected at com- template<class STRATEGY>
// pile-time, and 2) it does not have class Stat {
// to be changed at run-time. With a public:
// template, there is no need to spe- void readVector( int v[], int n ) {
// cify the interface in a SortImp imp_.sort( v, n );
// base class. The Stat class now has min_ = v[0]; max_ = v[n-1];
// an instance of the sort object, in- med_ = v[n/2]; }
// stead of a ptr to the base class. int getMin() { return min_; }
// The inheritance approach offers int getMax() { return max_; }
// more options and expressiveness. int getMed() { return med_; }
// The template approach offers mildly private:
// better efficiency. int min_, max_, med_;
STRATEGY imp_;
class Stat { /* Bubble sort */ };
public:
void readVector( int v[], int n ) { class SortBubble {
sort_( v, n ); public:
min_ = v[0]; max_ = v[n-1]; void sort( int v[], int n );
med_ = v[n/2]; } };
int getMin() { return min_; }
int getMax() { return max_; } class SortShell {
int getMed() { return med_; } public:
private: void sort( int v[], int n );
int min_, max_, med_; };
void sort_( int v[], int n ) {
for (int i=n-1; i > 0; i--) #include "strategy2.inc"
for (int j=0; j < i; j++)
if (v[j] > v[j+1]) { void main( void ) {
int t = v[j]; const int NUM = 9;
v[j] = v[j+1]; int array[NUM];
v[j+1] = t; } time_t t;
cout << "Bubble: "; srand((unsigned) time(&t));
for (int k=0; k < n; k++) cout << "Vector: ";
cout << v[k] << ' '; for (int i=0; i < NUM; i++) {
cout << endl; array[i] = rand() % 9 + 1;
} cout << array[i] << ' '; }
}; cout << endl;

void main( void ) { Stat<SortBubble> obj;
const int NUM = 9; obj.readVector( array, NUM );
int array[NUM]; cout << "min is " << obj.getMin()
time_t t; << ", max is " << obj.getMax()
srand((unsigned) time(&t)); << ", median is " << obj.getMed()
cout << "Vector: "; << endl;
for (int i=0; i < NUM; i++) {
array[i] = rand() % 9 + 1; Stat<SortShell> two;
cout << array[i] << ' '; } two.readVector( array, NUM );
cout << endl; cout << "min is " << two.getMin()
<< ", max is " << two.getMax()
Stat obj; << ", median is " << two.getMed()
obj.readVector( array, NUM ); << endl;
cout << "min is " << obj.getMin() }
<< ", max is " << obj.getMax()
<< ", median is " << obj.getMed() // Vector: 3 5 4 9 7 1 4 9 2
<< endl; // Bubble: 1 2 3 4 4 5 7 9 9
} // min is 1, max is 9, median is 4
// Shell: 1 2 3 4 4 5 7 9 9
// Vector: 6 9 9 8 6 5 7 9 2 // min is 1, max is 9, median is 4
// Bubble: 2 5 6 6 7 8 9 9 9
// min is 2, max is 9, median is 7



// Purpose. Strategy design pattern demo
//
// Discussion. The Strategy pattern suggests: encapsulating an algorithm
// in a class hierarchy, having clients of that algorithm hold a pointer
// to the base class of that hierarchy, and delegating all requests for
// the algorithm to that "anonymous" contained object. In this example,
// the Strategy base class knows how to collect a paragraph of input and
// implement the skeleton of the "format" algorithm. It defers some
// details of each individual algorithm to the "justify" member which is
// supplied by each concrete derived class of Strategy. The TestBed class
// models an application class that would like to leverage the services of
// a run-time-specified derived "Strategy" object.

#include <iostream.h>
#include <fstream.h>
#include <string.h>

class Strategy;

class TestBed {
public:
enum StrategyType { Dummy, Left, Right, Center };
TestBed() { strategy_ = NULL; }
void setStrategy( int type, int width );
void doIt();
private:
Strategy* strategy_;
};

class Strategy {
public:
Strategy( int width ) : width_( width ) { }
void format() {
char line[80], word[30];
ifstream inFile( "quote.txt", ios::in );
line[0] = '\0';

inFile >> word;
strcat( line, word );
while (inFile >> word)
{
if (strlen(line) + strlen(word) + 1 > width_)
justify( line );
else
strcat( line, " " );
strcat( line, word );
}
justify( line );
}
protected:
int width_;
private:
virtual void justify( char* line ) = 0;
};

class LeftStrategy : public Strategy {
public:
LeftStrategy( int width ) : Strategy( width ) { }
private:
/* virtual */ void justify( char* line ) {
cout << line << endl;
line[0] = '\0'; }
};

class RightStrategy : public Strategy {
public:
RightStrategy( int width ) : Strategy( width ) { }
private:
/* virtual */ void justify( char* line ) {
char buf[80];
int offset = width_ - strlen( line );
memset( buf, ' ', 80 );
strcpy( &(buf[offset]), line );
cout << buf << endl;
line[0] = '\0'; }
};

class CenterStrategy : public Strategy {
public:
CenterStrategy( int width ) : Strategy( width ) { }
private:
/* virtual */ void justify( char* line ) {
char buf[80];
int offset = (width_ - strlen( line )) / 2;
memset( buf, ' ', 80 );
strcpy( &(buf[offset]), line );
cout << buf << endl;
line[0] = '\0'; }
};

void TestBed::setStrategy( int type, int width ) {
delete strategy_;
if (type == Left) strategy_ = new LeftStrategy( width );
else if (type == Right) strategy_ = new RightStrategy( width );
else if (type == Center) strategy_ = new CenterStrategy( width ); }

void TestBed::doIt() { strategy_->format(); }

void main() {
TestBed test;
int answer, width;
cout << "Exit(0) Left(1) Right(2) Center(3): ";
cin >> answer;
while (answer)
{
cout << "Width: ";
cin >> width;
test.setStrategy( answer, width );
test.doIt();
cout << "Exit(0) Left(1) Right(2) Center(3): ";
cin >> answer;
}
return 0;
}

// Exit(0) Left(1) Right(2) Center(3): 2
// Width: 75
// The important lesson we have learned is that development for reuse is
// complex. If making a good design is difficult, then making a good reusable
// design is even harder, and any amount of process description cannot
// substitute for the skill, imagination, and experience of a good designer. A
// process can only support the creative work, and ensure that things are done
// and recorded properly. [Karlsson et al, REBOOT]
// Exit(0) Left(1) Right(2) Center(3): 3
// Width: 75
// The important lesson we have learned is that development for reuse is
// complex. If making a good design is difficult, then making a good reusable
// design is even harder, and any amount of process description cannot
// substitute for the skill, imagination, and experience of a good designer. A
// process can only support the creative work, and ensure that things are done
// and recorded properly. [Karlsson et al, REBOOT]