C++ 中的策略模式。实施选项

Question

这是所谓的简化示例（我希望 - 如果我错了，请纠正我）策略 模式：有一个类 FileWriter 将键值对写入文件并使用IFormatter 接口的对象来格式化正在写入的文本。有不同的格式化程序实现，并且在创建 FileWriter 时传递格式化程序对象。 这是这种模式的一个（不好的）实现：

#include <iostream>
#include <fstream>
#include <stdlib.h>
#include <sstream>

using namespace std;

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

class JsonFormatter : public IFormatter {
  public:
    string format(string key, double value) { 
        stringstream ss;
        ss << "\""+key+"\": " << value;
        return ss.str();
    }
};

class TabFormatter : public IFormatter {
  public:
    string format(string key, double value) { 
        stringstream ss;
        ss << key+"\t" << value;
        return ss.str();
    }
};

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

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

  private:
    ofstream f_;
    IFormatter& fmt_;
};    

可以看出，这种方法的主要缺点是它的不可靠性 - 传递给FileWriter 的Formatter 对象必须在FileWriter 的整个生命周期中都存在，因此像@ 这样的调用987654328@直接转至SegFault。

在这方面，我想讨论一下实现这种具有“易于使用”和简单要求的方法的其他选择：

• 可以在创建文件写入器时传递新的格式化程序，或者
• 现有的格式化程序可以传递使用。

我想出了下面描述的几种替代方案及其缺点 (IMO)：

• 模板： 将FileWriter 作为模板类，将精确的FormatterClass 作为参数； 缺点： 难看：FileWriter<JsonFormatter>("test.txt", JsonFormatter()) - 这里，JsonFormatter 被输入了两次。
• 原始指针： FileWriter("test.txt", new JsonFormatter()); 缺点 - 谁应该删除格式化程序对象？ FileWriter?如果是，那么一旦FileWriter 对象尝试删除格式化程序，传递现有格式化程序的地址将导致SegFault。
• 共享指针： FileWriter("test.txt", dynamic_pointer_cast<IFormatter*>(shared_ptr<JsonFormatter*>(new JsonFormatter())); 缺点： 很难调用，如果在创建文件编写器之前创建了格式化程序会怎样？

这里的最佳做法是什么？

更新

针对建议使用 std::function 的答案 - 如果 Formatter 可以存储状态（例如精度）并具有其他方法（例如 getHeader()）用于 CSV 文件怎么办？

此外，无法按值存储IFormatter，因为它是一个抽象类。

Answer 1

最简单的解决方案是使用：

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

另一个更好一点的选择是在IFormatter 中有一个clone() 函数。然后，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.

Answer 2

模板：将 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());`

Answer 3

这是标准库所做的（例如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，要么将生命周期管理权交给调用者（如果您重视效率而不是安全，这是一种非常有效的方法）。

Answer 4

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

您的格式化程序应该是一个函数，而不是一个接口。

调用者可以使用std::ref，如果他们想要保证生命周期，如果他们想要模糊的生命周期，可以包装一个共享的ptr，或者按值传递。

如果你想要一个更丰富的接口，你可以拿一堆这样的，或者编写一个这样的类（通过继承或手动编写notstd::functions）。

按值存储IFormatter fmt;，使用fmt(a,b) 而不是fmt.format(a,b)（干！）。如果需要，客户端代码可以使其成为 ref 或智能语义。

继承作为实现细节，而不是驱动您的设计，正在释放。