自动生成基于成员的操作？

Question

是否有任何内置的 C++ 机制能够自动生成代码以在类的每个成员上调用函数或运算符？

例如，如果我们有数百种类型需要使用一组特定的函数或运算符。在每个类型中，每种类型都需要为其所有成员调用相同的函数或运算符（仅此而已）。

对于一些具体的例子，我们可以说这些类型有函数Save()和Load()，或者流操作符<<和>>。当TYPE::Save(stream s)被调用时，我们如何自动执行A.Save(s) + B.Save(s) + C.Save(s)？如果代码只是简单地将执行传递给所有成员，有没有办法自动化这个过程？

这里是一些将自动生成的代码示例（只是Save() 函数）。 编辑注意：本例将所有 3 个成员显示为同一类型，但该解决方案应该适用于任何类型组合的成员，只要它们都共享相关的函数/运算符

class TYPE
{
protected:
    XTYPE A, B, C;
public:
    void Save(stream s)
    {
        A.Save( s );
        B.Save( s );
        C.Save( s );
    }
};

我的一个旧引擎使用疯狂的循环宏来实现这一点。它使使用宏构建类型变得更加容易（当有数百个类使用它们时），并且生成的类不难理解，但是宏本身很混乱且过于复杂。我希望有更多的东西......内置到语言中。

Answer 1

正如 P Kramer 所说，您可能会使用一些反射技巧。另一种选择是尝试减少您必须编写的代码量。一个技巧是创建一个接受 parameter pack 的 lambda，并使用 fold expression 对包中的每个项目应用一些操作，如下所示：

void Save(stream s)
{
    [&](auto&&... members) {
        (members.Save(s), ...);
    } (A, B, C);
}

即使A、B 和C 具有不同的类型，只要它们都具有Save() 成员函数，上述方法也有效。

您也可以使用常规模板函数而不是 lambda 来执行此操作，但以上是编写它的最短方法。它仍然需要您列出要应用该函数的成员变量的所有名称，您可以考虑将其放入宏中：

#define MEMBERS A, B, C

class TYPE
{
protected:
    XTYPE MEMBERS;
public:
    void Save(stream s)
    {
        [&](auto&&... members) {
            (members.Save(s), ...);
        } (MEMBERS);
    }
};

受文森特回答的启发，您还可以添加一个函数，该函数返回一个 std::tuple of references 到成员变量，然后可以使用 std::apply 和上面的 lambda 进行迭代：

class TYPE
{
protected:
    XTYPE A, B, C;

    auto Members()
    {
        return std::forward_as_tuple(A, B, C);
    }
public:
    void Save(stream s)
    {
        std::apply([&](auto&&... members) {
            (members.Save(s), ...);
        }, Members());
    }
};

灵活性稍差，但代码更紧凑的是创建一个成员函数，将函数作为参数，并将该函数应用于所有成员：

class TYPE
{
protected:
    XTYPE A, B, C;

    void ApplyToMembers(auto&& func)
    {
        [&](auto&&... members) {
            (func(members), ...);
        } (A, B, C);
    }
public:
    void Save(stream s)
    {
        ApplyToMembers([&](auto&& member){ member.Save(s); });
    }
};

Answer 2

这是一种真正面向对象的方法。您可以使用称为迭代器模式的设计模式。它基本上为TYPE 提供了一个名为“Iterator”的接口，该接口实现了hasNext() 和next()。然后将XTYPE 放入vector<XTYPE> 并在每个上执行。

class Iterator {
  virtual boolean hasNext() const = 0;
  virtual XTYPE *next() = 0;
};

class TYPE: public Iterator
{
private:
    size_t pos;
protected:
    vector<XTYPE> XTYPES;

public:
    void Save(stream s)
    {
        for (auto &XT : XTYPES ) {
            XT.Save(s);
        }
    }
    virtual boolean hasNext() const {
        if (pos => XTYPES.size() ) {
          return false;
        }
    };
    virtual XTYPE *next() {
        return XTYPES[pos++];
    }

};

基本上，您必须以一种或另一种方式确保您要调用的类型对您要调用的组有某种方式。您还可以保持A、B、C 不变，并在迭代器类中创建一个指向每个XTYPE 的指针向量。像这样：

class Iterator {
  virtual boolean hasNext() const = 0;
  virtual XTYPE *next() = 0;
protected:
  int pos;
  vector<XTYPE*> XTYPES_ITER;
};

class TYPE: public Iterator
{
protected:
    XTYPE A, B, C;
public:
    Type() {
        XTYPES_ITER = {&A, &B, &C};
    }
    void Save(stream s)
    {
        for (auto XT : XTYPES_ITER ) {
            XT->Save(s);
        }
    }
};