任何方式生成重复运算符<<定义？

Question

我有几十个这样类型的结构，我希望有一种聪明的方法来生成运算符<<使用宏或模板元编程的方法。另请注意，字节序也是考虑因素，并使其变得更加棘手......寻找一种至少与概述的解决方案一样高效的解决方案。

#define SEP '|'

struct MyStruct {
   char c;
   char s[10];
   uint32_t i;
   unsigned short us;

   friend ostream& operator<<(ostream& os, HeartbeatMessage& r) {
      return os \
         << "c=" << c << SEP
         << "s=" << s << SEP
         << "i=" << bswap_32(i) << SEP
         << "us=" << bswap_16(us) << SEP
}

Answer 1

正如评论中所指出的，如果有反思的话那就太好了。由于 C++ 没有内置反射，因此您能做的最好的事情就是使用一些库或自制代码来模拟反射并以通用方式实现打印。

我建议您使用Boost.Fusion，特别是BOOST_FUSION_ADAPT_STRUCT [Link] 使您的类型可作为融合序列使用，然后使用 Fusion 的 for_each 定义打印。

如果您有多种对成员进行操作的方法，那么基本上重复结构体的反射模拟定义所需的增加的工作将很快得到回报。但是，如果您真正拥有的只是单个运算符<<，则可能不值得付出努力（或者您决定，至少您可以在一个中心位置定义所有打印和格式）。

Answer 2

有一次我遇到类似的问题（自定义协议有很多不同的网络数据包），为此使用了 Boost Preprocessor，结果如下所示：

//////////////////////////////////////////////////////////////////////////
DEF_PACKET_STRUCT(name, members)

Example:

DEF_PACKET_STRUCT(
    Test_Struct,
    ((float) (f) (0.4f))
    ((std::string) (str))
);

defines Test_Struct with 2 members:
float f;
std::string str;

generates def ctor:
Test_Struct(): f(0.4f) {}

generates serialization and operator<<(std::ostream&...)

//////////////////////////////////////////////////////////////////////////
DEF_DERIVED_PACKET_STRUCT(name, bases, members)
the same as above + derivation from given bases

Example: 
DEF_DERIVED_PACKET_STRUCT(Test_Struct, 
    (Base1)(Base2), 
    ((std::string) (str_multi_derived) ("multi_derived"))
)

Note that even if it should be derived from single base, it should be specified in (), e.g. (Base1)

你的字节序功能可以按照与本示例中的成员默认值相同的方式实现

Answer 3

推测结构中的成员名称和类型不同，否则没有问题。

想必您需要您的结构是 POD 吗？

在这种情况下，对于不同的 POD 结构，主要约束是模板无法处理普通的 C++ 标识符（这是 POD 结构中的成员所必需的）。因此，您需要一个宏来定义operator<<;只有宏可以处理标识符。然后主要问题是，如何将可变数量的参数传递给宏？

好吧，有一些方法可以使用 Boost 库的宏支持来传递可变数量的参数并迭代它们，但这很复杂。

无论如何，您都必须提供数据成员名称，因此它不会比您已有的代码更干净。

记住这一点，并避免使用增强可变参数宏的诱惑，它可以看起来像这样（我不会使用它，但如果你喜欢它，你可以考虑为函数头声明定义一个宏）：

#include <iostream>
#include <string>

#define bswap_32( x )   x
#define bswap_16( x )   x
typedef unsigned    uint32_t;

char const  sep     = '|';

template< class Type >
inline void write( Type const& v, std::ostream& stream )
{
    stream << v;
}

template<>
inline void write( uint32_t const& v, std::ostream& stream )
{
    stream << bswap_32( v );
}

template<>
inline void write( unsigned short const& v, std::ostream& stream )
{
    stream << bswap_16( v );
}

template< class Type >
inline void write( char const legend[], Type const& v, std::ostream& stream )
{
    stream << legend;  write( v, stream );  stream << '|';
}

#define IMPLEMENT_OUTPUT_1(                     \
    name1                                       \
    )                                           \
    write( #name1 "=", r.name1, os );

#define IMPLEMENT_OUTPUT_2(                     \
    name1, name2                                \
    )                                           \
    IMPLEMENT_OUTPUT_1( name1 )                 \
    write( #name2 "=", r.name2, os );

#define IMPLEMENT_OUTPUT_3(                     \
    name1, name2, name3                         \
    )                                           \
    IMPLEMENT_OUTPUT_2( name1, name2 )          \
    write( #name3 "=", r.name3, os );

#define IMPLEMENT_OUTPUT_4(                     \
    name1, name2, name3, name4                  \
    )                                           \
    IMPLEMENT_OUTPUT_3( name1, name2, name3 )   \
    write( #name4 "=", r.name4, os );


struct MyStruct
{
   char c;
   char s[10];
   uint32_t i;
   unsigned short us;

//    friend std::ostream& operator<<( std::ostream& os, MyStruct const& r )
//    {
//       return os
//          << "c=" << r.c << sep
//          << "s=" << r.s << sep
//          << "i=" << bswap_32( r.i ) << sep
//          << "us=" << bswap_16( r.us ) << sep;
//     }

    friend std::ostream& operator<<( std::ostream& os, MyStruct const& r )
    {
        IMPLEMENT_OUTPUT_4( c, s, i, us )
        return os;
    }
};

int main()
{
    using namespace std;
    MyStruct const  o   = { 'A', "Bbbbbbb", 3, 4 };

    cout << o << endl;
}

同样，我不会使用这样的方案。但是，除了 Boost'ing 之外，它是不同 POD 结构中最接近的。所以我可能值得一看。

干杯&抱歉，这可能没有帮助，

Answer 4

有一个替代方案，但它变得很难看。
一种解决方案是创建一个通用基类，例如 Object（在其他语言中）。
下一步是创建一个指向 Object 的指针容器。
最后在某个时刻编写一个方法，将 operator<< 应用于容器中的每个对象（通过指针）。

否则，我会这样做：

struct Annotation_Interface
{
    virtual std::string annotate(const std::string& indentation = "") = 0;
};

class MyStruct : Annotation_Interface
{
   char c;
   char s[10];
   uint32_t i;
   unsigned short us;

  public:
    std::string annotate(const std::string& indentation)
    {
        std::ostringstream output;
        output << "c=" << c << SEP
         << "s=" << s << SEP
         << "i=" << bswap_32(i) << SEP
         << "us=" << bswap_16(us) << SEP;
        return output.str();
     }
};