This article aims to apply the Abstract Factory pattern in C++ applications by using the Singleton and AbstractFactory components implemented in the Loki library.
#include <iostream>
#include "AbstractFactory.h"
#include "Singleton.h"
using namespace std;
using namespace Loki;
// Abstract products A and B
struct A {};
struct B {};
// Concrete products A1 and B1
struct A1: public A
{
A1() { cout << "ctor A1" << endl; }
};
struct A2: public A
{
A2() { cout << "ctor A2" << endl; }
};
// Concrete products A2 and B2
struct B1: public B
{
B1() { cout << "ctor B1" << endl; }
};
struct B2: public B
{
B2() { cout << "ctor B2" << endl; }
};
// Traditional method begins
class AbstractFactory1
{
public:
virtual A* CreateA() = 0;
virtual B* CreateB() = 0;
};
class ConcreteFactory1 : public AbstractFactory1
{
public:
virtual A* CreateA() { return new A1(); }
virtual B* CreateB() { return new B1(); }
static ConcreteFactory1& Instance() {
static ConcreteFactory1 instance;
return instance;
}
protected:
ConcreteFactory1() {}
private:
ConcreteFactory1(const ConcreteFactory1&);
ConcreteFactory1& operator=(const ConcreteFactory1&);
};
class ConcreteFactory2 : public AbstractFactory1
{
public:
virtual A* CreateA() { return new A2(); }
virtual B* CreateB() { return new B2(); }
static ConcreteFactory2& Instance() {
static ConcreteFactory2 instance;
return instance;
}
protected:
ConcreteFactory2() {}
private:
ConcreteFactory2(const ConcreteFactory2&);
ConcreteFactory2& operator=(const ConcreteFactory2&);
};
// Traditional method ends
// Loki method begins
typedef AbstractFactory<TYPELIST_2(A, B)> AF;
typedef SingletonHolder<ConcreteFactory<AF, OpNewFactoryUnit, TYPELIST_2(A1, B1)> > SCF1;
typedef SingletonHolder<ConcreteFactory<AF, OpNewFactoryUnit, TYPELIST_2(A2, B2)> > SCF2;
// Loki method ends
void main()
{
cout << "Traditional method:" << endl;
// Create all concrete products using traditional method
A *pTA1 = ConcreteFactory1::Instance().CreateA();
B *pTB1 = ConcreteFactory1::Instance().CreateB();
A *pTA2 = ConcreteFactory2::Instance().CreateA();
B *pTB2 = ConcreteFactory2::Instance().CreateB();
cout << "Loki method:" << endl;
// Create all concrete products using Loki method
A *pLA1 = SCF1::Instance().Create<A>();
B *pLB1 = SCF1::Instance().Create<B>();
A *pLA2 = SCF2::Instance().Create<A>();
B *pLB2 = SCF2::Instance().Create<B>();
}