如何减少序列化当前所需的样板文件

在我看来，最好的全能解决方案是脚本语言中的外部 C++ 代码生成器。它具有以下优点：

• 灵活性：它允许您随时更改生成的代码。这非常好，有几个子原因：

  • 轻松修复所有受支持的旧版本中的错误。
  • 如果将来迁移到 C++11 或更高版本，请使用新的 C++ 功能。
  • 为其他语言生成代码。这是非常非常有用的（特别是如果您的组织很大和/或您有很多用户）。例如，您可以输出一个小型脚本库（例如 Python 模块），该库可用作 CLI 工具与硬件交互。根据我的经验，硬件工程师非常喜欢这一点。
  • 生成 GUI 代码（或 GUI 描述，例如 XML/JSON 格式，甚至是 Web 界面）——对于使用最终硬件和测试人员很有用。
  • 生成其他类型的数据。例如，图表、统计数据等。甚至是 protobuf 描述本身。

• 维护：它比 C++ 更容易维护。即使它是用不同的语言编写的，学习该语言通常也比让新的 C++ 开发人员深入研究 C++ 模板元编程（特别是在 C++03 中）更容易。

• 性能：它可以轻松减少 C++ 端的编译时间（因为您可以输出非常简单的 C++ - 甚至是普通的 C）。当然，发电机可能会抵消这一优势。在您的情况下，这可能不适用，因为您看起来无法更改客户端代码。

我已经在几个项目/系统中使用了这种方法，结果非常好。特别是使用硬件的不同替代方案（C++ 库，Python库，CLI，GUI...）可以非常赞赏。

---

旁注：如果生成的一部分需要解析已经存在的 C++ 代码（例如，带有要序列化的数据类型的标头，就像 OP 的类型一样）;那么一个非常好的解决方案是使用 LLVM/clang 的工具来做到这一点。Serialized

在我参与的一个特定项目中，我们必须自动序列化数十种 C++ 类型（用户随时可以更改这些类型）。我们设法通过仅使用 clang Python 绑定自动为其生成代码，并将其集成到构建过程中。虽然 Python 绑定没有公开所有 AST 细节（至少在当时），但它们足以为我们的所有类型（包括模板化类、容器等）生成所需的序列化代码。

你想要的是类似元组的东西，但不是实际的元组。假设所有类的实现基本上只是绑定它们的成员，这是我的假设代码：tuple_liketie()

template<typename T> struct tuple_like {
    bool operator==(const T& rhs) const {
        return this->tie() == rhs.tie();
    }
    bool operator!=(const T& rhs) const {
        return !operator==(*this,rhs);
    }        
};
template<typename T, typename Serialised> struct serialised_tuple_like : tuple_like<T> {
};
template<typename T, typename Serialised>
struct serialization_traits<serialised_tuple_like<T, Serialised>> {
    static Serialised encode(const T& bb) {
        Serialised s;
        s.tie() = bb.tie();
        return s;
    }
};

只要双方都实现适当的 tie（），这应该没问题。如果源类或目标类不直接在您的控制范围内，建议定义一个实现 tie（） 的继承类并使用它。要合并多个类，请定义一个帮助类，该类根据其成员实现 tie（）。

如果你的样板真的只是一堆普通的旧数据结构，带有简单的比较运算符，你可能会得到一些宏。

#define POD2(NAME, T0, N0, T1, N1) \
struct NAME { \
    T0 N0; \
    T1 N1; \
    NAME(const T0& N0, const T1& N1) \
        : N0(N0), N1(N1) {} \
    bool operator==(const NAME& rhs) const { return N0 == rhs.N0 && N1 == rhs.N1; } 
\
    bool operator!=(const NAME& rhs) const { return !operator==(rhs); } \
};

用法如下所示：

POD2(BarBaz, Bar, bar, Baz, baz)

template <>
struct serialization_traits<BarBaz> {
    static SerializedBarBaz encode(const BarBaz& bb) {
        SerializedBarBaz sbb;
        sbb.set_bar(bb.bar);
        sbb.set_baz(bb.baz);
        return sbb;
    }
};

您将需要 N 个宏，其中 N 是您拥有的参数计数的排列数，但这将是一次性的前期成本。

或者，您可以像您建议的那样利用元组为您完成许多繁重的工作。在这里，我创建了一个“NamedTuple”模板，用于命名元组的 getter。

#define NAMED_TUPLE2_T(N0, N1) NamedTuple##N0##N1

#define NAMED_TUPLE2(N0, N1) \
template <typename T0, typename T1> \
struct NAMED_TUPLE2_T(N0, N1) { \
    typedef std::tuple<T0, T1> TupleType; \
    const typename std::tuple_element<0, TupleType>::type& N0() const { return std::get<0>(tuple_); } \
    const typename std::tuple_element<1, TupleType>::type& N1() const { return std::get<1>(tuple_); } \
    NAMED_TUPLE2_T(N0, N1)(const std::tuple<T0, T1>& tuple) : tuple_(tuple) {} \
    bool operator==(const NAMED_TUPLE2_T(N0, N1)& rhs) const { return tuple_ == rhs.tuple_; } \
    bool operator!=(const NAMED_TUPLE2_T(N0, N1)& rhs) const { return !operator==(rhs); } \
    private: \
        TupleType tuple_; \
}; \
typedef NAMED_TUPLE2_T(N0, N1)

用法：

NAMED_TUPLE2(foo, bar)<int, int> FooBar;

template <>
struct serialization_traits<FooBar> {
    static SerializedFooBar encode(const FooBar& fb) {
        SerializedFooBar sfb;
        sfb.set_foo(fb.foo());
        sfb.set_bar(fb.bar());
        return sfb;
    }
};

我将基于您提出的解决方案，但改用 boost：：fusion：：tuples（假设这是允许的）。假设您的数据类型为

struct Foo{};
struct Bar{};
struct Baz{};
struct Fbr{};

您的数据是

struct some_data {
    Foo foo;
    Bar bar;
    Baz baz;
    Fbr fbr;
};

从评论中，我了解到您无法控制 SerialisedXYZ 类，但它们确实具有特定的接口。我会假设这样的事情已经足够接近（？）：

struct SerializedFooBar {

    void set_foo(const Foo&){
        std::cout << "set_foo in SerializedFooBar" << std::endl;
    }

    void set_bar(const Bar&){
        std::cout << "set_bar in SerializedFooBar" << std::endl;
    }
};

// another protobuf-generated class
struct SerializedBarBaz {

    void set_bar(const Bar&){
        std::cout << "set_bar in SerializedBarBaz" << std::endl;
    }

    void set_baz(const Baz&){
        std::cout << "set_baz in SerializedBarBaz" << std::endl;
    }
};

现在，我们可以减少样板，并将其限制为每个数据类型排列一个 typedef，并限制为 SerializedXYZ 类的每个set_XXX成员的一个简单重载，如下所示：

typedef boost::fusion::tuple<Foo, Bar> foobar;
typedef boost::fusion::tuple<Bar, Baz> barbaz;
//...

template <class S>
void serialized_set(S& s, const Foo& v) {
    s.set_foo(v);
}

template <class S>
void serialized_set(S& s, const Bar& v) {
    s.set_bar(v);
}

template <class S>
void serialized_set(S& s, const Baz& v) {
    s.set_baz(v);
}

template <class S, class V>
void serialized_set(S& s, const Fbr& v) {
    s.set_fbr(v);
}
//...

现在的好处是，您不再需要专门化您的serialization_traits。下面使用了 boost：：fusion：：fold 函数，我认为可以在您的项目中使用它：

template <class SerializedX>
class serialization_traits {

    struct set_functor {

        template <class V>
        SerializedX& operator()(SerializedX& s, const V& v) const {
            serialized_set(s, v);
            return s;
        }
    };

public:

    template <class Tuple>
    static SerializedX encode(const Tuple& t) {
        SerializedX s;
        boost::fusion::fold(t, s, set_functor());
        return s;
    }
};

以下是它如何工作的一些示例。请注意，如果有人尝试从不符合 SerializedXYZ 接口的 some_data绑定数据成员，编译器将通知您：

void send_msg(const SerializedFooBar&){
    std::cout << "Sent SerializedFooBar" << std::endl;
}

void send_msg(const SerializedBarBaz&){
    std::cout << "Sent SerializedBarBaz" << std::endl;
}

void send(const some_data& data) {
  send_msg( serialization_traits<SerializedFooBar>::encode(boost::fusion::tie(data.foo, data.bar)) );
  send_msg( serialization_traits<SerializedBarBaz>::encode(boost::fusion::tie(data.bar, data.baz)) );
//  send_msg( serialization_traits<SerializedFooBar>::encode(boost::fusion::tie(data.foo, data.baz)) ); // compiler error; SerializedFooBar has no set_baz member
}

int main() {

    some_data my_data;
    send(my_data);
}

代码在这里

编辑：

不幸的是，此解决方案无法解决 OP 的问题 #1。为了解决这个问题，我们可以定义一系列标签，每个数据成员一个标签，并遵循类似的方法。以下是标签以及修改后的函数：serialized_set

struct foo_tag{};
struct bar1_tag{};
struct bar2_tag{};
struct baz_tag{};
struct fbr_tag{};

template <class S>
void serialized_set(S& s, const some_data& data, foo_tag) {
    s.set_foo(data.foo);
}

template <class S>
void serialized_set(S& s, const some_data& data, bar1_tag) {
    s.set_bar1(data.bar1);
}

template <class S>
void serialized_set(S& s, const some_data& data, bar2_tag) {
    s.set_bar2(data.bar2);
}

template <class S>
void serialized_set(S& s, const some_data& data, baz_tag) {
    s.set_baz(data.baz);
}

template <class S>
void serialized_set(S& s, const some_data& data, fbr_tag) {
    s.set_fbr(data.fbr);
}

样板再次限制为每个数据成员一个，并且线性扩展，类似于我之前的答案。以下是修改后的serialization_traits：serialized_set

// the serialization_traits doesn't need specialization anymore :)
template <class SerializedX>
class serialization_traits {

    class set_functor {

        const some_data& m_data;

    public:

        typedef SerializedX& result_type;

        set_functor(const some_data& data)
        : m_data(data){}

        template <class Tag>
        SerializedX& operator()(SerializedX& s, Tag tag) const {
            serialized_set(s, m_data, tag);
            return s;
        }
    };

public:

    template <class Tuple>
    static SerializedX encode(const some_data& data, const Tuple& t) {
        SerializedX s;
        boost::fusion::fold(t, s, set_functor(data));
        return s;
    }
};

这是它的工作原理：

void send(const some_data& data) {

    send_msg( serialization_traits<SerializedFooBar>::encode(data,
    boost::fusion::make_tuple(foo_tag(), bar1_tag())));

    send_msg( serialization_traits<SerializedBarBaz>::encode(data,
    boost::fusion::make_tuple(baz_tag(), bar1_tag(), bar2_tag())));
}

在此处更新了代码

您是否考虑过稍微不同的方法？与其使用单独的 FooBar 和 BarBaz 表示形式，不如考虑类似于

message FooBarBaz {
  optional Foo foo = 1;
  optional Bar bar = 2;
  optional Baz baz = 3;
}

然后在应用程序代码中，您可以利用它，如下所示：

FooBarBaz foo;
foo.set_foo(...);
FooBarBaz bar;
bar.set_bar(...);
FooBarBaz baz;
baz.set_baz(...);
FooBarBaz foobar = foo;
foobar.MergeFrom(bar);
FooBarBaz barbaz = bar;
barbaz.MergeFrom(baz);

或者，您可以利用 protobuf 编码并序列化消息。（protobuf 本身实际上并没有序列化，您可以通过调用其上的 ToString 方法之一来获得它）。

// assume string_foo is the actual serialized foo from above, likewise string_bar
string serialized_foobar = string_foo + string_bar;
string serialized_barbaz = string_bar + string_baz;

FooBarBaz barbaz;
barbaz.ParseFromString(serialized_barbaz);

这确实假设您可以将大部分 API 从显式字段集移开，转向带有可选字段的常见消息，以仅发送您需要的内容。您可能希望在尝试使用特定进程所需的字段之前对系统的边缘进行包装，以断言已设置特定进程所需的字段，但这可能会导致其他地方的样板更少。字符串 concat 技巧在您通过一个实际上并不关心其中内容的系统的情况下也很方便。