2

问题如下：

考虑以下课程

class data : public base_data
{
  public:
    int a;
    std::string b;
    double c;
    ... // many other members
};

假设公开这个类的数据成员是完全有意义的。

现在考虑有很多这样的类，每个都有不同的成员，可能都派生自同一个基类“base_data”。

现在，这些类需要从其他任意数据表示中导出、导入、构造、“设置”和“获取”。

例如：

using any_map = boost::unordered_map < std::string, boost::any > ;

就是这样一种表示。

此外，所有这些操作都需要大量完成，即通过 base_data* 对象的集合以多态方式完成。

此问题的一种解决方案是在 base_data 中提供一个接口，如下所示

class base_data
{
 public:
   virtual void set(const any_map&) = 0;
   virtual any_map get() const = 0;
};

每个派生类都知道它的成员，因此它知道如何进行翻译。另外派生类可以提供以下形式的构造函数

data(const any_map&) {...}

允许轻松定义抽象工厂模式。

这个问题的另一个解决方案是在某些命名空间下为每个派生类型提供静态翻译函数，例如

static data convert(const any_map&);
static any_map convert(const data&);

因此，我们以“更少的 OO”解决方案和可能大规模执行这些翻译操作的能力为代价避免了派生类的污染。

如果我们考虑需要支持除 any_map 之外的许多表示的可能性，这也更有意义，例如

using boost::ptree;
using json_class;
using xml_class;

但再一次，它不是多态的。

我读过的大多数“翻译”设计模式都处理接口，但我还没有找到一种正式解决多态性上下文中数据的翻译/转换的模式。

我正在寻找对正式解决此问题的设计模式的参考，关于如何继续实施的建议和/或指出我的方法中明显的缺陷。

4

1 回答 1

1

根据评论中的要求，下面的代码说明了我所描述的访问者模式的使用。只需为输入、JSON、CSV 或您需要的任何格式添加额外的访问者。注意，访问者不需要修改来处理不同的记录结构——下面的实现只需要知道如何处理通过虚拟调度涉及的不同字段类型。所有这些最终都类似于 boost 序列化库，我也建议您查看一下。

#include <iostream>
#include <string>
#include <vector>
#include <sstream>

struct Visitor
{
    typedef const char* Identifier; // or string...

    Visitor(std::ostream& os) : os_(os) { }

    virtual Visitor& pre(Identifier) { return *this; }
    template <typename T> Visitor& operator()(Identifier id, const T& t)
    {
        std::ostringstream oss;
        oss << t;
        return operator()(id, oss.str());
    }
    virtual Visitor& operator()(Identifier, double) = 0;
    virtual Visitor& operator()(Identifier, const std::string&) = 0;
    virtual Visitor& post() { return *this; }

    std::ostream& os_;
};

struct Visitor__XML_Out : Visitor
{
    using Visitor::Visitor;

    Visitor& pre(Identifier i) override
    { os_ << '<' << i << '>'; i_ = i; return *this; }

    Visitor& operator()(Identifier f, double x) override
    { return out(f, x); }

    Visitor& operator()(Identifier f, const std::string& x) override
    { return out(f, x); }

    Visitor& post() override
    { os_ << "</" << i_ << '>'; return *this; }

  private:
    template <typename T>
    Visitor& out(Identifier f, const T& x)
    {
        os_ << '<' << f << '>' << x << "</" << f << '>';
        return *this;
    }

    Identifier i_;
};

struct Base_Data
{
   virtual void visit(Visitor& v) = 0;
};

struct Data : Base_Data
{
    int a_;
    std::string b_;
    double c_;

    Data(int a, const std::string& b, double c)
      : a_(a), b_(b), c_(c)
    { }

    void visit(Visitor& v) override
    {
        v.pre("Data")("a", a_)("b", b_)("c", c_).post();
    }
};

int main()
{
    Data d { 42, "hawk", 8.8 };
    Visitor__XML_Out xml(std::cout);
    d.visit(xml);
    std::cout << '\n';
}

输出：

<Data><a>42</a><b>hawk</b><c>8.8</c></Data>
于 2015-06-11T13:56:00.277 回答