Example of Factory Pattern in C++

This article presents the Factory Pattern in C++, a popular design pattern that helps create objects without specifying the exact class of the object. This increases flexibility and extensibility in the codebase.

The Factory Pattern is a design pattern that separates the process of creating an object from its usage. In this article, we will explore how to use the Factory Pattern to create different objects through a factory class.

C++ code

#include <iostream>
#include <memory>
#include <string>

// Interface for product
class Shape {
public:
    virtual void draw() = 0; // Pure virtual method
    virtual ~Shape() {}
};

// Concrete product class: Circle
class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle." << std::endl;
    }
};

// Concrete product class: Square
class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a square." << std::endl;
    }
};

// Factory class
class ShapeFactory {
public:
    // Shape creation method
    std::unique_ptr<Shape> createShape(const std::string& shapeType) {
        if (shapeType == "Circle") {
            return std::make_unique<Circle>();
        } else if (shapeType == "Square") {
            return std::make_unique<Square>();
        }
        return nullptr; // If no shape type is found
    }
};

int main() {
    ShapeFactory shapeFactory;

    // Create a circle
    auto shape1 = shapeFactory.createShape("Circle");
    shape1->draw();

    // Create a square
    auto shape2 = shapeFactory.createShape("Square");
    shape2->draw();

    return 0;
}

Detailed explanation

• Interface Shape: Defines the draw() method that all shapes will implement.
• Classes Circle and Square: Inherit from Shape, providing implementations for the draw() method.
• Class ShapeFactory: Contains the createShape() method that takes a shape type and returns the corresponding object.
• In the main() function: Uses ShapeFactory to create specific shapes and calls their draw() method.

System Requirements:

• A C++ compiler supporting C++11 or later.

How to install the libraries needed to run the C++ code above:

This program does not require any external libraries. You only need a C++ compiler like g++.

Tips:

• The Factory Pattern is very useful in large applications where creating complex objects can make the code hard to maintain. Use this design pattern when you need to create many different types of objects without being tied to a specific class.

---