Factory Method Pattern | C++ Design Patterns

Last Updated : 23 Oct, 2024

Factory Method Pattern provides an interface for creating objects but leaves the actual object instantiation to derived classes. This allows for flexibility in object creation and promotes loose coupling between the client code and the concrete products.

Factory-Design-Pattern-in-C-plus-plus — Factory Method Pattern | C++ Design Patterns

Table of Content

What is the Factory Method Design Pattern?

The Factory Method Design Pattern is a creational design pattern used in software development. It provides an interface for creating objects in a superclass while allowing subclasses to specify the types of objects they create.

This pattern simplifies the object creation process by placing it in a dedicated method, promoting loose coupling between the object creator and the objects themselves.
This approach enhances flexibility, extensibility, and maintainability, enabling subclasses to implement their own factory methods for creating specific object types.

Core Components of the Factory Method

Below are the main components of the Factory Design Pattern:

Creator: This is an abstract class or an interface that declares the factory method. The creator typically contains a method that serves as a factory for creating objects. It may also contain other methods that work with the created objects.
Concrete Creator: Concrete Creator classes are subclasses of the Creator that implement the factory method to create specific types of objects. Each Concrete Creator is responsible for creating a particular product.
Product: This is the interface or abstract class for the objects that the factory method creates. The Product defines the common interface for all objects that the factory method can create.
Concrete Product: Concrete Product classes are the actual objects that the factory method creates. Each Concrete Product class implements the Product interface or extends the Product abstract class.

Implementation of the Factory Method in C++

Let's implement the Factory Method Pattern in C++ step by step, explaining each part in detail. In this example, we'll create a simple shape factory that produces different shapes (e.g., Circle and Square).

Step 1: Define the Abstract Product (Shape)

C++

// Abstract product class class Shape { public:     virtual void draw() = 0;     virtual ~Shape() {} // Virtual destructor for polymorphism };

Here, we've defined an abstract class Shape with a pure virtual function draw(). This class represents the abstract product that all concrete products must inherit from.

Step 2: Define Concrete Products (Circle and Square)

C++

// 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;     } };

Here, we have two concrete classes, Circle and Square, that inherits from the Shape abstract class. Each concrete product (Circle and Square) provides its implementation of the draw() method.

Step 3: Define the Abstract Creator

C++

// Abstract creator class class ShapeFactory { public:     virtual Shape* createShape() = 0;     virtual ~ShapeFactory() {} // Virtual destructor for polymorphism };

The abstract creator class, ShapeFactory, declare a pure virtual function createShape(), which will be implemented by concrete creators to create specific shapes.

Step 4: Define Concrete Creators (CircleFactory and Square Factory)

C++

// Concrete creator class - CircleFactory class CircleFactory : public ShapeFactory { public:     Shape* createShape() override {         return new Circle();     } };  // Concrete creator class - SquareFactory class SquareFactory : public ShapeFactory { public:     Shape* createShape() override {         return new Square();     } };

In this step, we've created two concrete creator classes, CircleFactory and SquareFactory, which implement the createShape() method to create instances of Circle and Square, respectively.

Step 5: Client Code

Now, let's create a client to use the Factory Method Pattern:

C++

int main() {     ShapeFactory* circleFactory = new CircleFactory();     ShapeFactory* squareFactory = new SquareFactory();      Shape* circle = circleFactory->createShape();     Shape* square = squareFactory->createShape();      circle->draw(); // Output: Drawing a Circle     square->draw(); // Output: Drawing a Square      delete circleFactory;     delete squareFactory;     delete circle;     delete square;      return 0; }

In this client code, we first create instances of the concrete creators (circleFactory and squareFactory) and then use them to create instances of concrete products (cirlce and square). Finally, we call the draw() method on these objects, which produces the expected output.

Below is the complete combined code for the Factory Method Pattern in C++:

C++

// Abstract product class #include <bits/stdc++.h>; class Shape { public:     virtual void draw() = 0;     virtual ~Shape() {     } // Virtual destructor for polymorphism }; // 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;     } }; // Abstract creator class class ShapeFactory { public:     virtual Shape* createShape() = 0;     virtual ~ShapeFactory() {     } // Virtual destructor for polymorphism }; // Concrete creator class - CircleFactory class CircleFactory : public ShapeFactory { public:     Shape* createShape() override { return new Circle(); } };  // Concrete creator class - SquareFactory class SquareFactory : public ShapeFactory { public:     Shape* createShape() override { return new Square(); } }; int main() {     ShapeFactory* circleFactory = new CircleFactory();     ShapeFactory* squareFactory = new SquareFactory();      Shape* circle = circleFactory->createShape();     Shape* square = squareFactory->createShape();      circle->draw(); // Output: Drawing a Circle     square->draw(); // Output: Drawing a Square      delete circleFactory;     delete squareFactory;     delete circle;     delete square;          // Client code based on user-input          /* cout << "Enter shape type (circle or square): ";     string shapeType;     cin >> shapeType;      ShapeFactory* shapeFactory = nullptr;     if (shapeType == "circle") {         shapeFactory = new CircleFactory();     } else if (shapeType == "square") {         shapeFactory = new SquareFactory();     } else {         cout << "Invalid shape type entered." << endl;         return 1;     }      Shape* shape = shapeFactory->createShape();     shape->draw();      delete shapeFactory;     delete shape; */      return 0; }

Output

Drawing a Circle Drawing a Square

This implementation demonstrates the Factory Method Pattern, where:

The abstract creator (ShapeFactory) defines the factory method (createShape())
Concrete creators (CircleFactory and SquareFactory) implement this method to create concrete prodcuts (Circle and Square).
The client code interacts with the abstract creator, creating products without needing to know their specific types.
This promotes flexibility and decoupling between the client and product classes.

Use Cases of the Factory Method

Below are the main use cases of factory method design pattern:

Used in JDBC for creating connections and in frameworks like Spring for managing beans.
Libraries like Swing and JavaFX use factories to create flexible UI components.
Tools like Log4j rely on factories to create configurable loggers.
Factories help create objects from serialized data, supporting various formats.

Advantages of the Factory Method

Below are the main advantages of factory method design pattern:

Separates creation logic from client code, improving flexibility.
New product types can be added easily.
Simplifies unit testing by allowing mock product creation.
Centralizes object creation logic across the application.
Hides specific product classes from clients, reducing dependency.

Disadvantages of the Factory Method

Below are the main advantages of factory method design pattern:

Adds more classes and interfaces, which can complicate maintenance.
Slight performance impacts due to polymorphism.
Concrete creators are linked to their products.
Clients need knowledge of specific subclasses.
May lead to unnecessary complexity if applied too broadly.
Factory logic can be harder to test.

When to Use the Factory Method

Below is when to use factory method design pattern:

If your object creation process is complex or varies under different conditions, using a factory method can make your client code simpler and promote reusability.
The Factory Method Pattern allows you to create objects through an interface or abstract class, hiding the details of concrete implementations.
This reduces dependencies and makes it easier to modify or expand the system without affecting existing code.
If your application needs to create different versions of a product or may introduce new types in the future.
The Factory Method Pattern provides a flexible way to handle these variations by defining specific factory methods for each product type.

When Not to Use the Factory Method

Below is when to use factory method design pattern:

Avoid using the Factory Method pattern when your object creation process is straightforward and doesn’t require additional complexity.
Don’t implement it if you don’t need to hide concrete implementation details, as this can lead to unnecessary overhead.
Refrain from using the pattern if your application doesn’t anticipate creating different product versions or introducing new types in the future.
Skip the Factory Method if the added flexibility doesn’t provide significant benefits for your specific use case.

Conclusion

The Factory Method Pattern is a valuable tool in C++ for achieving flexible and extensible object creation mechanisms. By abstracting the creation process into separate factory methods, you can write more maintainable, modular and testable code. It is a fundamental patten to have in your arsenal when designing object-oriented systems, offering a solution to the often complex problem of object instantiation.

Abstract Factory Pattern | C++ Design Patterns

thesunpandey

Improve

Article Tags :