Abstract factory pattern

 It is one of creational design pattern.

The abstract design pattern provide an interface for creating family of related or dependent objects without specifying their concrete classes.

The Factory pattern construct single object where as abstract factory pattern construct multiple objects.

In the above UML diagram, There is one abstract factory classs which having 2 virtual funtion createButton and createCheck. In the derived classes LinuxFactory and WindowsFactory class which create corresponding button and check object.

If we create a application which have more than one theme dark theme or light theme, there we can use abstract factory pattern.

Code:

#include<iostream>
using namespace std;
class Button {
public:
virtual void Draw() = 0;

};
class Check {
public:
virtual void Draw() = 0;
};
class LinuxButton : public Button {
public:
void Draw() {
cout<<"linux button"<<endl;
}
};
class LinuxCheck: public Check {
public:
void Draw() {
cout<<"Linux Checkbox"<<endl;
}
};
class WindowsButton : public Button {
public:
void Draw() {
cout<<"Windows button"<<endl;
}
};
class WindowsCheck : public Check{
public:
void Draw() {
cout<<"Windows checkbox"<<endl;
}
};
class AbstractFactory {
public:
virtual Button* createButton() = 0;
virtual Check* createCheck() = 0;
};
class Windows : public AbstractFactory {
public:
Button* createButton() {
return new WindowsButton;
}
Check* createCheck() {
return new WindowsCheck;
}
};
class Linux: public AbstractFactory {
public:
Button* createButton() {
return new LinuxButton;
}
Check* createCheck() {
return new LinuxCheck;
}
};
class Client {
AbstractFactory *absFactory;
public:
Client(AbstractFactory *factory): absFactory(factory) {
}
void drawAll() {
absFactory->createButton()->Draw();
absFactory->createCheck()->Draw();
}
};
int main() {
AbstractFactory *factory;
#ifdef LINUX
factory = new Linux;
#else
factory = new Windows;
#endif
Client cl(factory);
cl.drawAll();
return 0;
}