Паттерн стратегии в C++. Варианты реализации

Самое простое решение — использовать:

JsonFormatter formatter;
FileWriter writer("test.txt", formatter);
// Use writer.

Другой вариант, который немного лучше, — иметь функцию clone() в IFormatter. Затем FileWriter может клонировать объект, стать владельцем клона и удалить его в своем деструкторе.

 class IFormatter {
   public:
     virtual string format(string key, double value) = 0;
     virtual IFormatter* clone() const = 0;
 };


 class FileWriter {
   public:  

     FileWriter(string fname, IFormatter const& fmt):fmt_(fmt.clone())
     {
         f_.open(fname.c_str(), ofstream::out);
     }

     ~FileWriter()
     {
        delete fmt_;
     }

     void writePair(string key, double value)
     {
         f_ << fmt_->format(key, value);
     }

   private:
     ofstream f_;
     IFormatter* fmt_;
 };    

Теперь вы также можете вызывать FileWriter с временным объектом.

FileWriter writer("test.txt", JsonFormatter());
// Use writer.

шаблоны: наличие FileWriter в качестве класса шаблона, который принимает точный FormatterClass в качестве аргумента; недостаток: некрасиво вызывать: FileWriter("test.txt", JsonFormatter()) - здесь JsonFormatter набирается дважды.

Больше шаблонов!

template<class Formatter> 
FileWriter<Formatter> makeFileWriter(const std::string& filename, const Formatter& formatter) 
{return FileWriter<Formatter>(filename, formatter);}

Та да! Теперь это так же просто, как:

auto fileWriter = makeFileWriter("test.txt", JSonFormatter());`

Это то, что делает стандартная библиотека (например, std::shared_ptr может принимать удаление). Formatter должно быть конструируемым при копировании, и, очевидно, выражение f << fmt(key, value) должно быть правильно построено.

class FileWriter {
public:
    template<typename Formatter>
    FileWriter(std::string fname, Formatter fmt) :
        fmt(fmt)
    {
        f.open(fname.c_str(), std::ofstream::out);
    }

    void writePair(std::string key, double value)
    {
        f << fmt(key, value);
    }

private:
    std::ofstream f;
    std::function<std::string (std::string, double)> fmt;
};

Если вам нужно более одной функции в вашем интерфейсе, вы можете использовать свой оригинальный подход, но контролировать время жизни средства форматирования с помощью std::unique_ptr или std::shared_ptr (не забудьте сделать деструктор виртуальным).

struct Formatter
{
    virtual ~Formatter() {}
    virtual std::string format(std::string key, double value) = 0;
};

class FileWriter {
public:
    FileWriter(std::string fname, std::unique_ptr<Formatter>&& fmt_)
    {
        if (!fmt_)
        {
            throw std::runtime_error("Formatter cannot be null");
        }

        f.open(fname.c_str(), std::ofstream::out);

        fmt = std::move(fmt_); // strong exception safety guarantee
    }

    void writePair(std::string key, double value)
    {
        f << fmt->format(key, value);
    }

private:
    std::ofstream f;
    std::unique_ptr<Formatter> fmt;
};

Если вы хотите передать существующий Formatter в FileWriter, вам нужно либо скопировать/переместить его в интеллектуальный указатель, чтобы передать право собственности, либо вам нужно обернуть его в интерфейс форматирования.

class FormatterProxy : public Formatter
{
public:
    FormatterProxy(Formatter& fmt) :
        fmt(fmt)
    {
    }

    std::string format(std::string key, double value)
    {
      return fmt.format(key, value);
    }

private:
  Formatter& fmt;
};

Это все еще имеет проблему управления временем жизни, которую вы пытаетесь избежать. Однако я не вижу никакого способа обойти это. Либо вы передаете уникальное или совместное владение Formatter FileWriter, либо оставляете управление жизненным циклом в руках вызывающей стороны (что является вполне допустимым подходом, если вы цените эффективность выше безопасности).

using IFormatter - std::function<std::string(std::string,double)>;

Ваш форматер должен быть функцией, а не интерфейсом.

Вызывающие могут использовать std::ref, если они хотят гарантировать время жизни, обернуть общий ptr, если они хотят туманное время жизни, или передать по значению.

Если вы хотите более богатый интерфейс, вы можете либо взять кучу таких, либо написать класс, который представляет собой кучу таких (либо через наследование, либо написав notstd::functions вручную).

Сохраните IFormatter fmt; по значению, используйте fmt(a,b) вместо fmt.format(a,b) (СУХОЙ!). Клиентский код может сделать его ref или умной семантикой, если захочет.

наследование как деталь реализации вместо того, чтобы управлять вашим дизайном, освобождает.