C++ 使用 union 或继承来解析数据

Question

我有一个场景，我在缓冲区中接收二进制数据(来自 com 端口、套接字或其他生产者等)。接收到的数据以不同的方式解释，通常在第一个字节或前几个字节中关闭消息头。我正在寻找最好的类结构来处理和解析这样的数据。这似乎很容易开发，但出于某种原因对我来说并不明显。

我想到的一个选择是在 POD 类型类中使用 union 。例如:

class Message {
  public:
    void DoSomething();

    int packetId;
    union {
      struct packetType1 { int A, int B, ... };
      struct packetType2 { float M, short N, ... };  // may be different size than packetType1
      ...
    };
};

void Message::DoSomething() {
  switch (packetId) {
  case 1:
    // do something using packetType1
    break;
  case 2:
    // do something using packetType2
    break;
  }
}

将指向此类对象的指针传递给以缓冲区作为输入的函数是否可以接受？这编译并且似乎工作。例如:

Message msg;
recvfrom(sock, (char*) &msg, sizeof(msg), ...);
msg.DoSomething();

这样做的一个缺点是 Message 中的成员变量是公共(public)的。我宁愿将它们设为私有(private)并提供只读访问方法。如果将 Message 中的成员变量设为私有(private)(或 protected )，这仍然有效吗？我认为不是，但不确定。

我考虑过使用继承，但问题是在接收到数据并解析 header 之前不知道需要哪个派生类。这个示例编译并且似乎工作，但这似乎是一个糟糕的方法。

class Message {
  virtual void DoSomething();

  int packetId;
};
class PacketType1 : public Message {
  void DoSomething();

  int A, B;
};
class PacketType2 : public Message {
  void DoSomething();

  float M;
  short N;
};

void Message::DoSomething() {
  switch (packetId) {
  case 1:
    ((PacketType1 *) this)->DoSomething();
    break;
  case 2:
    ((PacketType2 *) this)->DoSomething();
    break;
  }
}

用法:

Message* msg = (Message*) new unsigned char [MAX_MESSAGE_SIZE];
recvfrom(sock, (char*) msg, MAX_MESSAGE_SIZE, ...);
msg->DoSomething();

对于这种情况，最佳做法是什么？请温柔点，我不是专业或学校的软件专家，但有时是出于必要。这是那些时代之一。 :-) 谢谢。

编辑:一些人提到了字节序。我忘了在原始帖子中提到消息源可能具有与我的系统相同或不同的字节序，但这是先验已知的。我的意图是让 Message 类方法之一在必要时处理此问题。例如:

void Message::ByteSwap() {
  ByteSwap4(packetId);      // helper function that byte swaps a 4-byte word
  switch(packetId) {
  case 1:
    ByteSwap4(A);
    ByteSwap4(B);
    ...
    break;
  case 2:
    ByteSwap4(M);
    ByteSwap2(N);          // helper function that byte swaps a 2-byte word
    ...
    break;
  }
}

对于方法一，我忽略了我必须在定义 Message 类的 .h 文件中使用编译器指令 #pragma pack(1) 来强制成员按字节对齐。

关于消息的来源，我无法控制那些系统。我所拥有的是定义所发送消息的字节结构的正式文档。

感谢大家的参与!

Answer 1

你的第二种方法完全失败了，因为你在 recvfrom 中获取了一个字节序列，然后将其解释为非 POD 类型，它是未定义的并且可能会崩溃，如 Message 可能需要一个 vtable 以及为其设置的诸如此类的东西，这不太可能是正确的，除非接收到的数据是由同一台机器上完全相同的进程发送的。即使发件人在同一台机器上运行相同的代码，它也可能无法正常工作。

第一种方法涉及各种实现定义的关于结构和 union 的填充和对齐的细节，但只要发送方是使用针对相同架构的相同编译器构建的，它就可以正常工作。如果您使用 stdint.h 中的固定大小类型并仔细安排事情，以便对齐不太可能需要填充，那么它很可能没问题，但是如果您尝试在不同的体系结构之间执行此操作，您仍然存在潜在的字节序问题.

最好的方法是硬着头皮将消息定义为字节流，然后编写代码将对象显式转换为字节流，并从字节流构建新对象。一种相当有效的方法是具有虚拟编码和静态解码方法的继承层次结构:

class Message {
    virtual void DoSomething();
    virtual size_t Encode(char *buffer, size_t limit);
    static Message *Decode(char *buffer, size_t size);
};

class Type1 : public Message {
    virtual void DoSomething();
    virtual size_t Encode(char *buffer, size_t limit);
    static Type1 *Decode(char *buffer, size_t size);
};

Message *Message::Decode(char *buffer, size_t size) {
    if (size < 1) return 0; /* or throw some exception */
    switch(buffer[0]) {
    case 1: return Type1::Decode(buffer, size);
    case 2: return Type2::Decode(buffer, size);
    default: return 0; // or throw an exception
    }
}

编辑

如果您不关心编码，则可以省略编码方法——但如果您正在为通信的两端创建代码，则将编码和解码放在一起以保持一致是有意义的。

Decode 方法是静态的，因为它们在解码类型的对象存在之前被调用(甚至在您知道该类型是什么之前)。他们根据消息创建一个对象并将其返回。所以继续一点，你可能有:

Type1 *Type1::Decode(char *buffer, size_t size) {
    if (size != 9) return 0; // or throw an exception
    Type1 *rv = new Type1;
    rv->A = extract4byteInt(buffer+1);
    rv->B = extract4byteInt(buffer+5);
    return rv;
}

int extract4byteInt(char *buffer) {
    return ((buffer[0] & 0xff) << 24) +
           ((buffer[1] & 0xff) << 16) +
           ((buffer[2] & 0xff) << 8) +
           (buffer[3] & 0xff);
}

请注意，我们在这里显式地确定了消息所有部分的大小、填充和字节顺序，而不是依赖于编译器碰巧安排的内容。