Factory Pattern Polymorphic Implementation

Introduction to Pattern Application in C++

The Factory Pattern is a fundamental design pattern in object-oriented programming, particularly relevant in C++ for managing object creation and polymorphism. It enables the separation of object creation from their usage, promoting flexibility and maintainability. This article explores the implementation of the Factory Pattern in the context of polymorphic behavior, focusing on how it allows for dynamic object creation and method overriding.

Core Concepts of the Factory Pattern

The Factory Pattern involves the creation of objects through a factory class, which encapsulates the logic for generating instances of different classes. This pattern is especially useful when the exact class of an object is not known at the time of creation, or when the number of possible classes is large, making direct instantiation impractical.

In C++, the Factory Pattern often leverages abstract classes and virtual functions to achieve polymorphism. The factory class acts as a mediator, returning pointers to derived classes, enabling clients to interact with objects of different types without explicit knowledge of their specific implementations.

Polymorphic Implementation in C++

Polymorphism in C++ is achieved through virtual functions, where a derived class can override the implementation of a method defined in the base class. This allows objects of different classes to invoke the same method, leading to flexible and scalable code.

The Factory Pattern integrates polymorphism by ensuring that the factory class returns pointers to derived classes, allowing clients to call methods on these objects dynamically. This approach decouples the client from the specific classes, enhancing flexibility.

Implementation Details

Factory Class Design

The factory class is typically an abstract class or an interface that defines the method for object creation. For example:

class IFactory {
public:
    virtual std::unique_ptr<AbstractClass> create() = 0;
    virtual ~IFactory() = default;
};

Abstract Base Class

An abstract base class defines the common interface for all derived classes. It includes the virtual method that will be overridden by each concrete class:

class AbstractClass {
public:
    virtual void display() = 0;
    virtual ~AbstractClass() = default;
};

Concrete Classes

Each concrete class implements the virtual method defined in the abstract base class:

class DerivedClass1 : public AbstractClass {
public:
    void display() override {
        std::cout << "Derived Class 1" << std::endl;
    }
};

class DerivedClass2 : public AbstractClass {
public:
    void display() override {
        std::cout << "Derived Class 2" << std::endl;
    }
};

Factory Implementation

The factory class provides a method to create instances of the derived classes:

class Factory : public IFactory {
public:
    std::unique_ptr<AbstractClass> create() override {
        return std::make_unique<DerivedClass1>();
    }
};

Example: Polymorphic Factory Pattern

A simple example demonstrates how the Factory Pattern can be used to create and manage objects of different types:

int main() {
    IFactory* factory = std::make_unique<Factory>();
    std::unique_ptr<AbstractClass> obj1 = factory->create();
    obj1->display();

    std::unique_ptr<AbstractClass> obj2 = factory->create();
    obj2->display();
}

In this example, the factory class returns pointers to DerivedClass1 and DerivedClass2, allowing the client to call display() on objects of different types without knowing their specific implementations.

Conclusion

The Factory Pattern, when combined with polymorphism in C++, provides a powerful mechanism for managing object creation and flexibility. By encapsulating the logic for object instantiation and enabling dynamic method overriding, the pattern allows for efficient and maintainable code. The implementation details, including the design of the factory class, abstract base classes, and concrete classes, demonstrate how the pattern can be applied in practice to achieve polymorphic behavior.