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)（DRY！ 如果需要，客户端代码可以使其成为引用或智能语义。

继承作为实现细节，而不是驱动你的设计，是自由的。