有没有办法将操作应用于 N C++类成员在成员名称上循环（可能通过预处理器）？

Question

问题：

我有一个 C++ 类，其中包含大量（>100）个成员，其行为几乎相同：

• 相同类型

• 在函数中，每个成员都有对其执行的代码与其他成员完全相同，例如从构造函数中的映射进行赋值，其中映射键与函数中的成员键相同

• 这种行为的相同性在许多函数（> 20）中重复，当然每个函数中的行为是不同的，因此无法分解事物

• 流动，不断添加，有时会删除，其中一些（但不是全部）是由更改数据库表中的列驱动的。

正如您可以想象的那样，这在代码创建和维护方面带来了很大的麻烦，因为要添加新成员，您必须向每个函数添加代码 使用类似成员的地方。

我想要的解决方案示例

我需要的实际 C++ 代码（例如，在构造函数中）：

MyClass::MyClass(SomeMap & map) { // construct an object from a map 
    intMember1 = map["intMember1"];
    intMember2 = map["intMember2"];
    ... // Up to 
    intMemberN = map["intMemberN"];
}

我希望能够编写的 C++ 代码 ：

MyClass::MyClass(SomeMap & map) { // construct an object from a map 
#FOR_EACH_WORD Label ("intMember1", "intMember2", ... "intMemberN")
    $Label = map["$Label"];
#END_FOR_EACH_WORD
}

要求

• 解决方案必须与 GCC 兼容（如果重要的话，使用 Nmake 作为 make 系统）。 不用关心其他编译器。

• 解决方案可以是预处理器级别的，也可以是可编译的。我对其中任何一个都很好；但到目前为止，我所有的研究都让我得出这样的结论：后者在 C++ 中显然是不可能的（我非常想念 Perl，现在我被迫使用 C++！）

• 解决方案必须至少在某种程度上是“行业标准”（例如，Boost 很棒，但是 Joe-Quick-Fingers 创建一次并发布在他的博客上的自定义 Perl 脚本却不是。哎呀，我可以轻松编写该 Perl 脚本，我更像是一位 Perl 专家，而不是 C++ 专家 - 我只是无法让我的大公司软件工程领域的大佬们同意使用它:) )

• 该解决方案应该允许我声明 ID 列表（理想情况下，仅在一个头文件中而不是在每个“#FOR_EACH_WORD”指令中）正如我在上面的示例中所做的那样）

• 解决方案不能仅限于“从数据库表创建对象”构造函数。有许多函数需要此功能，其中大多数不是构造函数。

• “将它们的所有值都放在一个向量中，然后在向量上运行“for”循环”的解决方案是一个显而易见的解决方案，并且不能使用 - 代码位于许多应用程序使用的库中，成员是公共的，遗憾的是，重写这些应用程序以使用向量成员而不是命名成员是不可能的。

Answer 1

Boost 包含一个很棒的预处理器库，您可以使用它来生成此类代码：

#include <boost/preprocessor/repetition.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/preprocessor/cat.hpp>

typedef std::map<std::string, int> SomeMap;

class MyClass
{
public:
    int intMember1, intMember2, intMember3;

    MyClass(SomeMap & map) 
    {
        #define ASSIGN(z,n,_) BOOST_PP_CAT(intMember, n) = map[ BOOST_PP_STRINGIZE(BOOST_PP_CAT(intMember, n))];
        BOOST_PP_REPEAT_FROM_TO(1, 4, ASSIGN, nil)
    }
};

Answer 2

Boost.Preprocessor 提出了许多方便的宏来执行此类操作。 Bojan Resnik 已经提供了 使用此库的解决方案，但它假设每个成员名称都以相同的方式构造。

由于您明确要求可以声明 ID 列表，因此这里有一个解决方案应该可以更好地满足您的需求。

#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/stringize.hpp>

// sequence of member names (can be declared in a separate header file)
#define MEMBERS (foo)(bar)

// macro for the map example
#define GET_FROM_MAP(r, map, member) member = map[BOOST_PP_STRINGIZE(member)];

BOOST_PP_SEQ_FOR_EACH(GET_FROM_MAP, mymap, MEMBERS)
// generates
// foo = mymap["foo"]; bar = mymap["bar];

-------

//Somewhere else, we need to print all the values on the standard output:
#define PRINT(r, ostream, member) ostream << member << std::endl;

BOOST_PP_SEQ_FOR_EACH(PRINT, std::cout, MEMBERS)

如您所见，您只需编写一个表示要重复的模式的宏，并将其传递给 BOOST_PP_SEQ_FOR_EACH 宏。

Answer 3

您可以执行以下操作：创建一个适配器类或修改现有类以具有指向这些字段的指针向量，将所有相关成员变量的地址添加到类构造函数中的该向量中，然后在需要时运行 for-对该向量进行循环。这样，您就不会（或几乎不会）更改外部用户的类，并且具有良好的 for 循环功能。

Answer 4

当然，最明显的问题是：为什么你的班级有 100 名成员？这看起来不太理智。

假设它是理智的——你看过 boost预处理器库？我自己从未使用过它（正如一位朋友过去常说的：这样做会带来黑暗的一面），但据我所知，它应该是完成这项工作的工具。

Answer 5

偷偷地在您自己的机器上使用 perl 来创建构造函数。然后要求增加你的薪水，因为你成功地维护了这么大的代码块。

Answer 6

您可以使用预处理器来定义成员，然后使用相同的定义来访问它们：

#define MEMBERS\
  MEMBER( int, value )\
  SEP MEMBER( double, value2 )\
  SEP MEMBER( std::string, value3 )\

struct FluctuatingMembers {
#define SEP ;
#define MEMBER( type, name ) type name
MEMBERS
#undef MEMBER
#undef SEP
};


.. client code:
FluctuatingMembers f = { 1,2., "valuesofstringtype" };
std::cout <<
  #define SEP <<
  #define MEMBER( type, name ) #name << ":" << f.##name
  MEMBERS;
  #undef MEMBER
  #undef SEP

它对我有用，但很难调试。

Answer 7

您还可以实现基于成员指针的访问者模式。在采用预处理器解决方案之后，这个解决方案变得更加可调试。

struct FluctuatingMembers {
    int v1;
    double v2;
    std::string v3;
    template<typename Visitor> static void each_member( Visitor& v );
};

template<typename Visitor> void FluctuatingMembers::each_member( Visitor& v ) {
  v.accept( &FluctuatingMembers::v1 );
  v.accept( &FluctuatingMembers::v2 );
  v.accept( &FluctuatingMembers::v3 );
}


struct Printer {
    FluctuatingMembers& f;
    template< typename pt_member > void accept( pt_member m ) const {
        std::cout << (f::*m) << "\n";
    }
};

// you can even use this approach for visiting
// multiple objects simultaneously
struct MemberComparer {

    FluctuatingMembers& f1, &f2;
    bool different;
    MemberComparer( FluctuatingMembers& f1, FluctuatingMembers& f2 )
      : f1(f1),f2(f2)
      ,different(false)
    {}

    template< typename pt_member > void accept( pt_member m ) {
      if( (f1::*m) != (f2::*m) ) different = true;          
    }
};

... client code:
FluctuatingMembers object1 = { 1, 2.2, "value2" }
                 , object2 = { 1, 2.2, "valuetoo" };

Comparer compare( object1, object2 );
FluctuatingMembers::each_member( compare );
Printer pr = { object1 };
FluctuatingMembers::each_member( pr );

Answer 8

为什么不在运行时执行呢？ （我真的很讨厌宏黑客）

从某种意义上说，您真正要求的是类元数据。

所以我会尝试这样的事情：（

class AMember{
 ......
};

class YourClass{
    AMember member1;
    AMember member2;
    ....
    AMember memberN;
    typedef AMember YourClass::* pMember_t;
    struct MetaData : public std::vector<std::pair<std::string,pMember_t>>{
        MetaData(){
            push_back(std::make_pair(std::string("member1"),&YourClass::member1));
            ...
            push_back(std::make_pair(std::string("memberN"),&YourClass::memberN)); 
        }
    };

    static const MetaData& myMetaData() {
        static const MetaData m;//initialized once
        return m;
    }

    YourClass(const std::map<std::string,AMember>& m){
        const MetaData& md = myMetaData();
        for(MetaData::const_iterator i = md.begin();i!= md.end();++i){
            this->*(i->second) = m[i->first];
        }
    }
    YourClass(const std::vector<std::pair<std::string,pMember_t>>& m){
        const MetaData& md = myMetaData();
        for(MetaData::const_iterator i = md.begin();i!= md.end();++i){
            this->*(i->second) = m[i->first];
        }
    }
};

很确定我的语法正确，但这是一篇机械帖子而不是代码帖子）

RE：
在函数中，每个成员都具有与其他成员相同的代码，例如从构造函数中的映射进行赋值，其中映射键与成员键相同

这是上面处理的。

关于：
成员列表非常流动，不断添加，有时会删除，其中一些（但不是全部）是由更改数据库表中的列驱动的。

当您添加新的 AMember（例如 newMember）时，您所拥有的一切要做的就是使用以下内容更新元数据构造函数：

 push_back(make_pair(std::string("newMember"),&YourClass::newMember)); 

RE：
这种行为的相同性在许多函数（>20）中重复出现，当然每个函数中的行为是不同的，因此无法将事情分解出来。

你有机制来应用同样的方法构建函数的习惯用法

，例如： setAllValuesTo(const AMember& value)

 YourClass::setAllValuesTo(const AMember& value){
    const MetaData& md = myMetaData();
    for(MetaData::const_iterator i = md.begin();i!= md.end();++i){
        this->*(i->second) = value;
    }
 }

如果您对函数指针或模板函数有一点创意，您可以分解出变异操作，并在集合的基础上对 YourClass' AMember 执行任何您想要的操作。包装这些通用函数（可能需要函数或函数指针）以在接口中实现当前的 20 个公共方法集。

如果您需要更多元数据，只需将元数据映射的共域扩展到指向成员的指针之外。 （当然上面的 i-> 第二个会改变）

希望这会有所帮助。

Answer 9

您可以做类似他的事情：

#define DOTHAT(m) m = map[#m]
DOTHAT(member1); DOTHAT(member2);
#undef DOTHAT

这并不完全符合您的描述，但最接近它，可以节省您的打字时间。

Answer 10

也许我想做的是利用运行时多态性（动态调度）。使用执行常见操作的方法为这些成员创建一个父类。成员从该父类派生出他们的类。需要不同方法实现的人会实现自己的方法。如果他们也需要完成常见的工作，那么在方法内部，他们可以向下转换为基类并调用其方法的版本。

然后，您在原始类中所要做的就是调用每个方法的成员。

Answer 11

我会推荐一个小型命令行应用程序，用您或您的团队最精通的任何语言编写。

在源文件中添加某种模板语言。对于这样的事情，您不需要实现一个成熟的解析器或任何类似的东西。只需在行首查找易于识别的字符以及一些要替换的关键字即可。

使用命令行应用程序将模板化源文件转换为真实源文件。在大多数构建系统中，通过添加构建阶段或简单地告诉构建系统：“使用 MyParser.exe 处理 *.tmp 类型的文件”，这应该很容易自动完成，

这是我正在讨论的示例：

MyClass.tmp

MyClass::MyClass(SomeMap & map) { // construct an object from a map
▐REPLACE_EACH, LABEL, "intMember1", "intMember2, ... , "intMemberN"
▐   LABEL = map["$Label"];
}

我使用“▐”作为示例，但任何不会作为一行中第一个字符出现的字符都是完全可以接受的。

现在，您可以将这些 .tmp 文件视为源文件，并自动生成实际的 C++ 代码。

如果您曾经听说过“编写代码的代码”这句话，这就是它的意思:)

Answer 12

这里已经有很多好的答案和想法，但为了多样性，我将提出另一个。

在 MyClass 的代码文件中将是：

struct MemberData
{
    size_t Offset;
    const char* ID;
};

static const MemberData MyClassMembers[] = 
{
    { offsetof(MyClass, Member1), "Member1" },
    { offsetof(MyClass, Member2), "Member2" },
    { offsetof(MyClass, Member3), "Member3" },
};

size_t GetMemberCount(void)
{
    return sizeof(MyClassMembers)/sizeof(MyClassMembers[0]);
}

const char* GetMemberID(size_t i)
{
    return MyClassMembers[i].ID;
}

int* GetMemberPtr(MyClass* p, size_t i) const
{
    return (int*)(((char*)p) + MyClassMembers[i].Offset);
}

这样就可以将所需的构造函数编写为：

MyClass::MyClass(SomeMap& Map)
{
    for(size_t i=0; i<GetMemberCount(); ++i)
    {
        *GetMemberPtr(i) = Map[GetMemberID(i)];
    }
}

当然，对于对所有成员进行操作的任何其他函数，您将编写类似的循环。

现在，此技术存在一些问题：

• 对成员的操作使用运行时循环，而不是其他会产生展开的操作序列的解决方案。
• 这绝对取决于每个成员具有相同的类型。虽然OP允许这样做，但人们仍然应该评估这种情况将来是否会改变。其他一些解决方案没有此限制。
• 如果我没记错的话，offsetof 仅被 C++ 标准定义为适用于 POD 类型。在实践中，我从未见过它失败。不过我还没有使用过所有的 C++ 编译器。特别是，我从未使用过 GCC。因此，您需要在您的环境中对此进行测试，以确保它确实按预期工作。

这些是否是问题，您必须根据自己的情况进行评估。

---

现在，假设这项技术可用，那么它有一个很好的优点。这些 GetMemberX 函数可以转换为类的公共静态/成员函数，从而提供对代码中更多位置的通用成员访问。

class MyClass
{
public:
    MyClass(SomeMap& Map);

    int Member1;
    int Member2;
    int Member3;

    static size_t GetMemberCount(void);
    static const char* GetMemberID(size_t i);
    int* GetMemberPtr(size_t i) const;
};

如果有用，您还可以添加 GetMemberPtrByID 函数来搜索给定的字符串 ID 并返回指向相应成员的指针。

---

到目前为止，这种想法的一个缺点是存在可能将成员添加到类中但不能添加到 MyClassMembers 数组中的风险。然而，这种技术可以与 xtofl 的宏解决方案结合起来，以便单个列表可以填充类和数组。

标头中的更改：

#define MEMBERS\
    MEMBER( Member1 )\
    SEP MEMBER( Member2 )\
    SEP MEMBER( Member3 )\

class MyClass
{
public:
    #define SEP ;
    #define MEMBER( name ) int name
    MEMBERS;
    #undef MEMBER
    #undef SEP

    // other stuff, member functions, etc
};

以及代码文件中的更改：

const MemberData MyClassMembers[] = 
{
    #define SEP ,
    #define MEMBER( name ) { offsetof(MyClass, name), #name }
    MEMBERS
    #undef MEMBER
    #undef SEP
};

---

注意：我在此处的示例中留下了错误检查。根据其使用方式，您可能希望确保数组边界不会因调试模式断言和/或释放模式检查而溢出，这些检查将针对错误索引返回 NULL 指针。或者在适当的情况下使用一些例外。

当然，如果您不担心检查数组边界时出错，那么 GetMemberPtr 实际上可以更改为其他可返回对该成员的引用的内容。