Abstract Factory Pattern | C++ Design Patterns

Abstract Factory Pattern is a creational design pattern used in object-oriented programming. It provides an interface for creating families of related or dependent objects without specifying their concrete classes. This pattern is a way to encapsulate the creation of objects and ensure that they are compatible and properly configured. In this article, we’ll look at the Abstract Factory Pattern in detail with an example

UML Diagram for the Abstract Factory Pattern in C++ Design Patterns

UML Diagram for Abstract Factory Pattern

• Abstract Factory Interface: This interface defines a set of methods for creating various abstract product types. Each method in the interface corresponds to a different product family.
• Concrete Factories: Concrete factory classes implement the Abstract Factory interface. Each concrete factory is responsible for creating a specific family of related products.
• Abstract Product Interfaces: These interfaces define the structure and behavior of the product objects created by the factory. Each product family has its set of abstract product interfaces.
• Concrete Products: Concrete product classes implement the abstract product interfaces. These classes represent the actual objects that the client code will use.
• Client: The client code works with the abstract factory and abstract product interfaces. It doesn’t need to know the concrete classes of the products it uses. Instead, it relies on the factory to create compatible objects.

Note: The Abstract Factory Pattern is particularly useful in situations where we need to ensure that the products created by a factory are consistent and work together.

Example:

In a GUI application, you might have different themes (e.g., light theme and dark theme) where each theme includes a set of related UI components lie buttons, windows, dialogs, etc. Abstract Factory Pattern can be used to create UI components that are consistent with the selected theme without the client code having to be aware of the specific theme or component implementations.

Implementation of the Abstract Factory Pattern in C++ Design Patterns

Let’s look at the example of the Abstract Factory Pattern in the context of creating different types of pizzas in a pizza restaurant.

Example:

We’ll have two styles of pizza: “New York” and “Chicago,” each with its own set of pizza types.

• Step 1: We’ll define an abstract factory interface (PizzaFactory) with methods for creating different types of pizzas for different styles.
• Step 2: We’ll create two concrete factories (NewYorkPizzaFactory and ChicagoPizzaFactory) implementing this interface and create corresponding New York and Chicago style pizzas.
• Step 3: We’ll create an abstract product interface (Pizza) that defines the methods that concrete pizzas must implement.Concrete pizza classes (NewYorkCheesePizza, NewYorkPepperoniPizza, ChicagoCheesePizza, ChicagoPepperoniPizza) implement the abstract Pizza interface for each style.
• The client code will create and prepare pizzas using the abstract factories and interact with them without needing to know the specific pizza styles or implementations.

This pattern allows for easy addition of new pizza styles without affecting the existing code

C++

#include <iostream>

// Abstract Product Interface
class Pizza {
public:
    virtual void bake() = 0;
    virtual void cut() = 0;
    virtual void box() = 0;
};

// Concrete New York Cheese Pizza
class NewYorkCheesePizza : public Pizza {
public:
    void bake() override
    {
        std::cout << "Baking New York-style cheese pizza."
                  << std::endl;
    }

    void cut() override
    {
        std::cout << "Cutting New York-style cheese pizza."
                  << std::endl;
    }

    void box() override
    {
        std::cout << "Boxing New York-style cheese pizza."
                  << std::endl;
    }
};

// Concrete New York Pepperoni Pizza
class NewYorkPepperoniPizza : public Pizza {
public:
    void bake() override
    {
        std::cout
            << "Baking New York-style pepperoni pizza."
            << std::endl;
    }

    void cut() override
    {
        std::cout
            << "Cutting New York-style pepperoni pizza."
            << std::endl;
    }

    void box() override
    {
        std::cout
            << "Boxing New York-style pepperoni pizza."
            << std::endl;
    }
};

// Concrete Chicago Cheese Pizza
class ChicagoCheesePizza : public Pizza {
public:
    void bake() override
    {
        std::cout << "Baking Chicago-style cheese pizza."
                  << std::endl;
    }

    void cut() override
    {
        std::cout << "Cutting Chicago-style cheese pizza."
                  << std::endl;
    }

    void box() override
    {
        std::cout << "Boxing Chicago-style cheese pizza."
                  << std::endl;
    }
};

// Concrete Chicago Pepperoni Pizza
class ChicagoPepperoniPizza : public Pizza {
public:
    void bake() override
    {
        std::cout << "Baking Chicago-style pepperoni pizza."
                  << std::endl;
    }

    void cut() override
    {
        std::cout
            << "Cutting Chicago-style pepperoni pizza."
            << std::endl;
    }

    void box() override
    {
        std::cout << "Boxing Chicago-style pepperoni pizza."
                  << std::endl;
    }
};

// Abstract Factory Interface
class PizzaFactory {
public:
    virtual Pizza* createCheesePizza() = 0;
    virtual Pizza* createPepperoniPizza() = 0;
};

// Concrete New York Pizza Factory
class NewYorkPizzaFactory : public PizzaFactory {
public:
    Pizza* createCheesePizza() override
    {
        return new NewYorkCheesePizza();
    }

    Pizza* createPepperoniPizza() override
    {
        return new NewYorkPepperoniPizza();
    }
};

// Concrete Chicago Pizza Factory
class ChicagoPizzaFactory : public PizzaFactory {
public:
    Pizza* createCheesePizza() override
    {
        return new ChicagoCheesePizza();
    }

    Pizza* createPepperoniPizza() override
    {
        return new ChicagoPepperoniPizza();
    }
};

int main()
{
    // Create a New York Pizza Factory
    PizzaFactory* newYorkFactory
        = new NewYorkPizzaFactory();
    Pizza* newYorkCheesePizza
        = newYorkFactory->createCheesePizza();
    Pizza* newYorkPepperoniPizza
        = newYorkFactory->createPepperoniPizza();

    // Create a Chicago Pizza Factory
    PizzaFactory* chicagoFactory
        = new ChicagoPizzaFactory();
    Pizza* chicagoCheesePizza
        = chicagoFactory->createCheesePizza();
    Pizza* chicagoPepperoniPizza
        = chicagoFactory->createPepperoniPizza();

    // Order and prepare the pizzas
    newYorkCheesePizza->bake();
    newYorkCheesePizza->cut();
    newYorkCheesePizza->box();

    newYorkPepperoniPizza->bake();
    newYorkPepperoniPizza->cut();
    newYorkPepperoniPizza->box();

    chicagoCheesePizza->bake();
    chicagoCheesePizza->cut();
    chicagoCheesePizza->box();

    chicagoPepperoniPizza->bake();
    chicagoPepperoniPizza->cut();
    chicagoPepperoniPizza->box();

    // Clean up
    delete newYorkFactory;
    delete newYorkCheesePizza;
    delete newYorkPepperoniPizza;
    delete chicagoFactory;
    delete chicagoCheesePizza;
    delete chicagoPepperoniPizza;

    return 0;
}

Output:

Baking New York-style cheese pizza.
Cutting New York-style cheese pizza.
Boxing New York-style cheese pizza.
Baking New York-style pepperoni pizza.
Cutting New York-style pepperoni pizza.
Boxing New Y…

Advantages of the Abstract Factory Pattern in C++ Design Patterns

• Consistency: It ensures that objects created by a factory are compatible and consistent within a family, improving the overall system’s integrity.
• Flexibility: The pattern allows for the easy addition of new product families or variations without modifying existing client code.
• Encapsulation: Concrete classes are encapsulated within their respective factories, reducing dependencies and making it easier to manage changes.

Disadvantages of the Abstract Factory Pattern in C++ Design Patterns

• Complexity: Implementing the pattern can lead to a large number of classes and interfaces, potentially increasing code complexity.
• Rigidity: Modifying or extending a product family may require changes in multiple places, making the system less flexible.
• Runtime Costs: Creating objects through factories can introduce some runtime overhead, although it’s usually negligible.