委托给子组件的模式

Question

在我正在工作的产品中，非常基本的场景之一是类的序列化。通常，要序列化的类会在其子组件上调用序列化

例如，如果有一个类 st class A{B;C;D;} 那么A.Pack就会调用pack B、C、D 上的函数。

由于有很多这样的类，因此必须一遍又一遍地重复相同的代码模式。 是否可以将此行为封装在模式中（可能使用模板和继承）

Answer 1

一位评论者写道：

如果您的意思是“有没有一种方法可以编写模板来自动调用每个成员变量上的方法？”，那么答案是否定的...

我的（有点邪恶）反驳是是的，如果该方法是析构函数...

#include <iostream>
using namespace std;

bool Enable = false;

template <typename T>
class DS : public T {
public:
    ~DS() {
        if (Enable) T::Serialize();
    }
};

class A {
protected:
    void Serialize() { cout << "A" << endl; }
};

class B {
protected:
    void Serialize() { cout << "B" << endl; }
};

typedef DS<A> DSA;
typedef DS<B> DSB;

class C {
protected:
    void Serialize() { cout << "C" << endl; }
private:
    DSA a;
    DSB b;
};

typedef DS<C> DSC;

int
main()
{
    DSC c;
    {
        DSC c_copy = c;
        Enable = true;
    }
    Enable = false;
}

输出是相反的顺序，因此要重建对象，您必须解析序列化数据并将每个完成的对象推送到堆栈上。然后，复合对象就会知道要从堆栈中弹出多少个子对象。或者，当然，序列化可以进入中间结构。

另一个有趣的想法是在启动时使用此黑客一次（仅创建和销毁一个特殊对象），其中来自析构函数的回调将创建一个描述原始对象的数据结构。

我还注意到隐式复制构造函数有可能出现类似的滥用，并且可能按正向顺序......

Answer 2

使模板执行此操作的常用方法是使用类型列表：

#include <iostream>

// typelist definition
struct Empty {};

template < typename H, typename T = Empty >
struct Cons {
    typedef H head;
    typedef T tail;
};

// interfaces all items support
class IPack
{
public:
    virtual void Pack() = 0;
};

// some packable items
class Fee : public IPack
{
public:
    virtual void Pack() {
        std::cout << "Packed Fee\n";
    }
};

class Fi : public IPack
{
public:
    virtual void Pack() {
        std::cout << "Packed Fi\n";
    }
};

class Fo : public IPack
{
public:
    virtual void Pack() {
        std::cout << "Packed Fo\n";
    }
};

class Fum : public IPack
{
public:
    virtual void Pack() {
        std::cout << "Packed Fum\n";
    }
};

// these two templates create a composite IPack from a list 
// of the types of its parts
template <typename Types>
class PackList : public PackList<typename Types::tail>
{
protected:
    typedef typename Types::head Item;
    Item item;

public:
    virtual void Pack() {
        item.Pack();
        PackList<typename Types::tail>::Pack();
    }
};

template <>
class PackList<Empty> : public IPack
{
public:
    virtual void Pack() {}
};

// FeeFiFoFum is a composite of four items
class FeeFiFoFum : public PackList<Cons<Fee,Cons<Fi,Cons<Fo,Cons<Fum> > > > >
{
};

// create a FeeFiFoFum and call pack on it, which calls pack on its parts
int main ()
{
    FeeFiFoFum giant;

    giant.Pack();
}

从类型列表创建的组合的正确实现为您提供了成员等的访问器，但这足以显示它们是如何工作的，并打印出它打包的内容Fee、Fi、Fo 和 Fum，未指定任何行为。

Answer 3

有助于实现此目的的一种可能的设计是使用复合模式。您的组件（借用维基百科绘图）是可打包的，它将实现模板Pack()方法可以做类似这样的事情：

GetChildren();
    for each child:
        child.Pack()
PackImpl();

PackImpl()是Packable中的一个纯虚方法，所有继承它的类都适当地实现了它。 GetChildren() 将返回一个 STL 容器（可能为空），用于迭代。它可以在Packable中实现，并带有一个私有成员集合来存储子对象。基本上，然后您从 Packable 继承所有类，实现 PackImpl()，然后就完成了。

请注意，如果您的继承层次结构依赖于直接作为成员的子部分，这将导致问题。如果您已经从聚合的角度解决了这个问题，那么这应该会很有效。

Answer 4

访客模式可能会有所帮助。

http://en.wikipedia.org/wiki/Visitor_pattern

这样做的想法是将来自每个对象的处理的遍历逻辑（逐步遍历对象）。在这种情况下，每个对象的逻辑正在序列化（编码）单个对象（当然也可以反序列化）。使用普通的 OOP 技术，这应该相当简单并且重复性极低。

实现遍历和访问者模式特定的代码很烦人，但它主要是样板文件，应该是一次性的事情。