C++ example for Abstract Factory Design Pattern

The Abstract Factory Design Pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes. The following UML class diagram explains how the Abstract Factory fits with the rest.


The following is example of Abstract factory design pattern:

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//Abstract Factory is part of Creational Patterns
//Creational Patterns deal with initializing and configuring classes and objects
//Abstract Factory creates an instance of several families of classes

//We will take an example of Animal Classes and Abstract them.
//There are 2 types of animals; Herbivores and Carnivores.
//The rule of nature is that Carnivores eats Herbivores which will be shown
//Different animas live in different continents but the same rule applies

#include<iostream>
#include<string>

using namespace std;

//The Herbivore class - The 'AbstractProductA' abstract class
class Herbivore
{
public:
 virtual const string& getName(void)=0;
};

//Lets define couple of Herbivores called Cow and Deer
class Cow : public Herbivore //The 'ProductA1' class
{
public:
 Cow():name("Cow"){};
 //default destructor
  const string& getName(void) {return name;}
private:
 string name;
};

class Deer : public Herbivore //The 'ProductA2' class
{
public:
 Deer():name("Deer"){};
 //default destructor
  const string& getName(void) {return name;}
private:
 string name;
};

//The Carnivore class - The 'AbstractProductB' abstract class
class Carnivore
{
public:
 virtual const string& getName(void)=0;
 virtual void eat(Herbivore& h) = 0;
};

//Lets define couple of Carnivores called Lion and Wolf
class Lion : public Carnivore //The 'ProductB1' class
{
public:
 Lion():name("Lion"){};
 const string& getName(void) {return name;}
 void eat(Herbivore& h) //override
  {
   cout << name << " eats " << h.getName() << endl;
 }
private:
 string name;
};

class Wolf : public Carnivore //The 'ProductB2' class
{
public:
 Wolf():name("Wolf"){};
 const string& getName(void) {return name;}
 void eat(Herbivore& h) //override
  {
   cout << name << " eats " << h.getName() << endl;
 }
private:
 string name;
};

//The 'AbstractFactory' abstract class
class ContinentFactory
{
public:
 virtual Herbivore& CreateHerbivore() = 0;
 virtual Carnivore& CreateCarnivore() = 0;
};

class AfricaFactory : public ContinentFactory //The 'ConcreteFactory1' class
{
 Herbivore& CreateHerbivore()
 {
   return *(dynamic_cast<Herbivore *>(new Cow()));
 }
 Carnivore& CreateCarnivore()
 {
   return *(dynamic_cast<Carnivore *>(new Lion()));
 }
};

class AmericaFactory : public ContinentFactory //The 'ConcreteFactory2' class
{
 Herbivore& CreateHerbivore()
 {
   return *(dynamic_cast<Herbivore *>(new Deer()));
 }
 Carnivore& CreateCarnivore()
 {
   return *(dynamic_cast<Carnivore *>(new Wolf()));
 }
};

//The 'Client' class
class AnimalWorld
{
public:
 AnimalWorld(ContinentFactory& factory):_herbivore(factory.CreateHerbivore()),_carnivore(factory.CreateCarnivore())
 {
 }
 void RunFoodChain()
 {
   _carnivore.eat(_herbivore);
 }
private:
 Herbivore& _herbivore;
 Carnivore& _carnivore;
};

int main()
{
 //Create and run African Animal World
  ContinentFactory& africa = *(dynamic_cast<ContinentFactory *>(new AfricaFactory()));
 AnimalWorld& world1 = *(new AnimalWorld(africa));
 world1.RunFoodChain();

 // Create and run the American animal world
  ContinentFactory& america = *(dynamic_cast<ContinentFactory *>(new AmericaFactory()));
 AnimalWorld& world2 = *(new AnimalWorld(america));
 world2.RunFoodChain();

 return 0;
}

The output is as follows:



For more details please see: http://www.dofactory.com/Patterns/PatternAbstract.aspx

An example of Interface class

Sometimes it is simple and helpful to define a class that does nothing but defines a standardised interface that can be used by other classes to make sure the implementation follows a standard set of input and output paramaters. Also this approach results in faster code runs and more maintainable code.

//Program tested on Microsoft Visual Studio 2008 - Zahid Ghadialy
//This program shows an example of Interface class

#include<iostream>

using namespace std;

//Shape is an Interface Class. No data and everything pure virtual
class Shape {
public:
  virtual void Area(int length, int breadth) = 0;
  virtual void Perimeter(int length, int breadth) = 0;
  //Note, no data
};

//Derived class - Inherits Shape as Public
class Rectangle : public Shape {
public:
  void Area(int length, int breadth);
  void Perimeter(int length, int breadth);
private:
  int someData;
};

//Derived class - Inherits Shape as Public
class Triangle : public Shape {
public:
  void Area(int length, int breadth);
  void Perimeter(int length, int breadth);
private:
  int someData;
};

int main()
{
  Rectangle r;
  Triangle t;

  cout<<"\n\n";
  r.Area(3,4);
  r.Perimeter(3,4);

  t.Area(3,4);
  t.Perimeter(3,4);

  cout<<"\n\n";
  return 0;
}

void Rectangle::Area(int length, int breadth)
{
  cout<<"\nThe Area of Rectangle for length = "<<length<<" and\
  breadth = "<<breadth<<" is "<<(length * breadth)<<endl;
}

void Rectangle::Perimeter(int length, int breadth)
{
  cout<<"\nThe Perimeter of Rectangle for length = "<<length<<" and\
  breadth = "<<breadth<<" is "<<2 * (length + breadth)<<endl;
}

void Triangle::Area(int length, int breadth)
{
  cout<<"\nThe Area of Triangle for length = "<<length<<" and\
  breadth = "<<breadth<<" is "<<(length * breadth)/2<<endl;
}

void Triangle::Perimeter(int length, int breadth)
{
  cout<<"\nThe Perimeter of Triangle for length = "<<length<<" and\
  breadth = "<<breadth<<" is "<<(length * breadth)/3<<endl;
}

In the above example, Shape class is an 'abstract class'. All the interfaces are 'pure interfaces'. It contains no data. The derived classes now have to define the interace functions.

The output is as follows: