// Purpose. Abstract Factory #include <iostream.h>
//
// Discussion. Trying to maintain class Widget { public:
// portability across multiple "plat- virtual void draw() = 0;
// forms" routinely requires lots of };
// preprocessor "case" stmts. The
// Factory pattern suggests defining class MotifBtn : public Widget {
// a creation services interface in a public:
// Factory base class, and implement- void draw() { cout << "MotifBtn"
// ing each "platform" in a separate << endl; }
// Factory derived class. };

#include <iostream.h> class WindowsBtn : public Widget {
public:
class Widget { public: void draw() { cout << "WindowsBtn"
virtual void draw() = 0; << endl; }
}; };

class MotifBtn : public Widget { class Factory { public:
public: virtual Widget* createBtn() = 0;
void draw() { cout << "MotifBtn" };
<< endl; }
}; class MotifFactory : public Factory {
public:
class WindowsBtn : public Widget { Widget* createBtn() {
public: return new MotifBtn; }
void draw() { cout << "WindowsBtn" };
<< endl; }
}; class WindowsFactory : public Factory {
public:
void doThisWindow() { Widget* createBtn() {
// create window, attach btn return new WindowsBtn; }
#ifdef MOTIF };
Widget* w = new MotifBtn;
#else // WINDOWS Factory* factory;
Widget* w = new WindowsBtn;
#endif void doThisWindow() {
w->draw(); } // create window, attach btn
Widget* w = factory->createBtn();
void doThatWindow() { w->draw(); }
// create window, attach btn
#ifdef MOTIF void doThatWindow() {
Widget* w = new MotifBtn; // create window, attach btn
#else // WINDOWS Widget* w = factory->createBtn();
Widget* w = new WindowsBtn; w->draw(); }
#endif
w->draw(); } void main( void )
{
void main( void ) #ifdef MOTIF
{ factory = new MotifFactory;
// create window, attach btn #else // WINDOWS
#ifdef MOTIF factory = new WindowsFactory;
Widget* w = new MotifBtn; #endif
#else // WINDOWS
Widget* w = new WindowsBtn; // create window, attach btn
#endif Widget* w = factory->createBtn();
w->draw(); w->draw();

doThisWindow(); doThisWindow();
doThatWindow(); doThatWindow();
} }

// WindowsBtn // MotifBtn
// WindowsBtn // MotifBtn
// WindowsBtn // MotifBtn



// Purpose. Abstract Factory design pattern demo.
//
// Discussion. "Think of constructors as factories that churn out objects".
// Here we are allocating the constructor responsibility to a factory object,
// and then using inheritance and virtual member functions to provide a
// "virtual constructor" capability. So there are two dimensions of
// decoupling occurring. The client uses the factory object instead of "new"
// to request instances; and, the client "hard-wires" the family, or class, of
// that factory only once, and throughout the remainder of the application
// only relies on the abstract base class.

#include <iostream.h>

class Shape {
public:
Shape() { id_ = total_++; }
virtual void draw() = 0;
protected:
int id_;
static int total_;
};
int Shape::total_ = 0;

class Circle : public Shape { public:
void draw() { cout << "circle " << id_ << ": draw" << endl; } };
class Square : public Shape { public:
void draw() { cout << "square " << id_ << ": draw" << endl; } };
class Ellipse : public Shape { public:
void draw() { cout << "ellipse " << id_ << ": draw" << endl; } };
class Rectangle : public Shape { public:
void draw() { cout << "rectangle " << id_ << ": draw" << endl; } };

class Factory { public:
virtual Shape* createCurvedInstance() = 0;
virtual Shape* createStraightInstance() = 0;
};
class SimpleShapeFactory : public Factory { public:
Shape* createCurvedInstance() { return new Circle; }
Shape* createStraightInstance() { return new Square; }
};
class RobustShapeFactory : public Factory { public:
Shape* createCurvedInstance() { return new Ellipse; }
Shape* createStraightInstance() { return new Rectangle; }
};

void main() {
#ifdef SIMPLE
Factory* factory = new SimpleShapeFactory;
#elif ROBUST
Factory* factory = new RobustShapeFactory;
#endif
Shape* shapes[3];

shapes[0] = factory->createCurvedInstance(); // shapes[0] = new Ellipse;
shapes[1] = factory->createStraightInstance(); // shapes[1] = new Rectangle;
shapes[2] = factory->createCurvedInstance(); // shapes[2] = new Ellipse;

for (int i=0; i < 3; i++)
shapes[i]->draw();
}

// ellipse 0: draw
// rectangle 1: draw
// ellipse 2: draw