C++ 通过TCP/IP连接进行流式传输

我发现自己经常遇到这样的情况：我需要通过TCP/IP连接发送一组消息。我从来没有找到设计消息类的好方法。我希望有一个消息基类，其中所有消息都来自它。由于每条消息都有不同的字段，这将允许我通过成员变量或方法访问字段。类似于

class message_base
{
  public:
   message_base();
   virtual ~message_base();

   unsigned int type;
};

class message_control : public message_base
{
  public:
   message_control();
   virtual ~message_control();

   unsigned int action;
};

通过这种方式，我可以创建一个message_控件并访问操作成员，以便分配给和读取。我还可以在不编写太多代码的情况下传递消息

当我需要发送消息时，问题就出现了。如果我覆盖操作符>，那么我可以一次通过一个变量发送消息。该解决方案的问题是，由于发送数据的调用太多，上下文开关将猛击处理器。此外，流式处理操作符在socket类中结束，而不是在message类中结束

socket& socket::operator<<(message_control& message)
{
   sock << type;
   sock << action;
}

socket&socket:：operator“该解决方案的问题是，由于要发送数据的调用太多，上下文切换将使处理器崩溃。此外，流式处理操作符将socket类终止，而不是我希望它存在的message类。”

第二个问题的解决方案是定义
操作符。你看过使用ACE吗？可能没有什么帮助，所以这只是一个注释。但我实现的模式几乎与上一个模式完全相同。除了在我的例子中缓冲区更合理一点之外，我有一些大的结构要在每条消息旁边传递，因此缓冲区变得非常有用，在我看来是合适的。尽管如此，它对我来说还是很好，即使我没有传递大数据，它也会同样好用！DeusAduro——我还需要将它用于大型（100 KB）消息。一旦我让我的缓冲区类在高线程环境中正常工作，事情就变得容易多了。我发现这是最好的解决方案，我很高兴我不是唯一的一个。我的答案是无核的，因为它与你澄清后的问题无关。在这方面，如果相同的逻辑已经适用于您，并且内存使用模式不是太“急促”（因为缓冲区太大），onebyone的建议看起来更合理。
socket& socket::operator<<(message_control& message)
{
   byte* buffer = new byte[sizeof(message.type) + sizeof(message.action)];

   memcpy(buffer, message.type, sizeof(message.type));
   memcpy(buffer + sizeof(message.type), message.action, sizeof(message.action));

   sock.send(buffer);
}

class socket
{
  public:
   socket();
   ~socket();

   socket& operator<<(buffer& buff);
};

class buffer
{
  public:
   buffer() {m_buffer = new byte[initial_size];}
   ~buffer() {delete [] m_buffer;}

   buffer& operator<<(unsigned int value);

  private:
   byte* m_buffer;
};

void message_control::serialize(buffer& buff)
{
   buff << type;
   buff << action;
}

sock << type;
sock << action;

stringstream ss;
ss << type;
ss << action;
sock << ss.str();