Factory Method

Intent

Defines an interface for creating an object but lets subclasses decide which class to instantiate.

Problem

Your logistics app only knows trucks. Adding ships means touching every place that calls new Truck().

Solution

Replace direct construction with a call to a factory method that subclasses override. Client code works with the product interface only.

Real-world analogy

Structure

Hover or tap a numbered role to highlight it in the diagram.

1. 1Product — Product declares the interface common to everything the creator and its subclasses can produce.
2. 2ConcreteProductA — Concrete Products are the different implementations of that interface.
3. 3Creator — Creator declares the factory method that returns a Product. Its main job is still business logic that uses the product.
4. 4ConcreteCreatorA — Concrete Creators override the factory method to return a different product type.

Try it

logistics.plan()

Code example

struct Transport {
    virtual ~Transport() = default;
    virtual std::string deliver() const = 0;
};
struct Truck : Transport { std::string deliver() const override { return "by road"; } };
struct Ship  : Transport { std::string deliver() const override { return "by sea"; } };

class Logistics {
public:
    virtual ~Logistics() = default;
    std::string plan() const { return createTransport()->deliver(); }
protected:
    virtual std::unique_ptr<Transport> createTransport() const = 0;   // factory method
};

class RoadLogistics : public Logistics {
protected:
    std::unique_ptr<Transport> createTransport() const override {
        return std::make_unique<Truck>();
    }
};

Applicability

How to implement

1. Make all products follow a common interface
2. Add an empty factory method to the creator, returning the product interface
3. Replace constructor calls in the creator with calls to the factory method
4. Create a creator subclass for each product type and override the factory method

Pros and cons

Relations with other patterns

Check yourself