La fabbrica dovrebbe creare oggetti di strategia di contesto o concreti nel modello di strategia-fabbrica?

In un tipico modello di strategia

class Strategy
{
public:
    virtual int execute() const = 0;
}

class StrategyA : public Strategy
{
public:
    int execute() const override;
}

class StrategyB : public Strategy
{
public:
    int execute() const override;
}

class Context
{
public:
    Context() = delete;
    Context(Strategy* the_strategy);
    int execute() const;
private:
    Strategy* the_strategy_;
}

Dovrebbe essere preferibile utilizzare un Context di fabbrica con la strategia corretta iniettata

class ContextFactory
{
public:
    std::unique_ptr<Context> make(/*some parameters*/);
}

void ContextUser(/*some parameters*/)
{
    ContextFactory a_context_factory;
    auto a_context = a_context_factory.make(/*some parameters*/);
}

o Strategy di fabbrica, lasciando l'iniezione al chiamante?

class StrategyFactory
{
public:
    std::unique_ptr<Strategy> make(/*some parameters*/);
}

void ContextUser(/*some parameters*/)
{
    StrategyFactory a_strategy_factory;
    Context a_context(a_strategy_factory.make(/*some parameters*/));
}

Mi sembra che il Context factory debba essere preferito come:

1. Meno lavoro per il chiamante.
2. Factory può gestire la durata di oggetti Strategy .
3. Facilita il cambiamento del design; se il modello di strategia è stato modificato in un altro progetto, ad esempio ereditarietà, il codice cliente non cambierebbe, solo la fabbrica.