好吧，Walter通过引入一个通用的基本类型解决了这个想法。但通常有两种方法可以处理编码/编组数据。

• 将网络字节直接映射到数据结构，例如 C/C++ POD 类型
• 使用独立于系统的数据表示格式，例如Google Protobuf，XDR，ASN.1等等(甚至是非二进制的，如XML，JSON，YAML...)

案例 1：类似 POD 的处理

C/C++ 吊舱

实际上，我唯一不同意 Walter 想法的部分是引入虚拟基类。 特别是，因为该类型不再是 POD，并且无法将其 1：1 映射到网络字节，并且需要复制数据。

通常，示例中的A、B等类型被设计为 POD。这允许非常有效地编组/解组它们而无需复制。

假设你有 smth。 比如：

struct incoming_header
{
std::int32_t a;
std::int64_t b;
};
struct outgoing_header
{
std::int32_t a;
std::int64_t b;
char c[SIZE};
};

在这里，我们使用C++标准的保证长度整数来确保我们处理字段的确切长度。不幸的是，标准定义它们是可选的，因此在您的目标平台上可能不可用(实际上很少用于成熟的硬件，并且在某些嵌入式硬件上可能是这种情况)。

发送容器

现在，由于这些类型是 POD，我们可以通过简单地通过网络推送它们的字节来简单地发送它们。

所以下面的伪代码是完全可以的：

outgoing_header oh{...};
send(&oh, sizeof(oh));

接收容器

通常您知道如何(从您的协议中您需要多少字节)，因为它们都被复制到连续的缓冲区中，您可以获得该缓冲区的正确视图。假设我们在这一点上不处理大/小端序问题。然后网络代码通常为您接收字节，并说明这些字节有多少。

因此，在这一点上，让我们依靠我们现在只能接收outgoing_header并且我们的缓冲区足够大以包含整个消息长度。

然后代码通常类似于：

constexpr static size_t max_size = ...;
char buf[max_size]{};
size_t got_bytes = receive(&buf, max_size);
// now we need to interpret these bytes as outgoing_header
outgoing_header* pheader = reinterpret_cast<outgoing_header*>(&buf[0]);
// now access the header items
pheader->a;
pheader->b;

不涉及副本，只是一个指针投射。

解决您的问题

通常，任何二进制协议都有一个发送方和接收方可以依赖的公共标头。有编码，正在传输哪个消息，它有多长，可能是协议版本等。

您需要做的是引入一个通用标头，在您的情况下，它应该携带字段a和b。

struct base_header
{
std::int32_t a;
std::int64_t b;
};
// Note! Using derivation will render the type as non-POD, thus aggregation
struct incoming_header
{
base_header base;
};
struct outgoing_header
{
base_header base;
char c[SIZE};
};

现在incoming_header和outgoing_header都是 POD。这里需要做的是将缓冲区强制转换为指向base_header的指针，并获取感兴趣的a和b：

base_header* pbase_header = reinterpret_cast<base_header*>(&buf[0]);
do_smth(pbase_header->a, pbase_header->b);

案例 2：独立于系统的数据表示格式

该方法的替代方法是使用boost::variant类，或者切换到 C++17std::variant.如果您不能拥有 POD，并且具有某种自定义序列化格式，例如 Google Protobuf 或类似内容......

使用变体，您可以只定义您的协议，即可能到达的消息/标头：

typedef boost::variant<boost::none, IncomingHeader, OutgoingHeader> message_header;
message_header get_header(char* bytes, size_t size)
{
// dispatch bytes and put the message to variant:
// let's say we get OutgoingHeader
OutgoingHeader h{/* init from bytes here */};
return h; // variant has implicit ctor to accept OutgoingHeader object
}

现在，您可以使用手工制作的访问者类型来获取所需的值：

struct my_header_visitor
{
typedef void result_type;
explicit my_header_visitor(some_context& ctx)
: ctx_{ctx}
{}
template<class T>
result_type operator()(T const&)
{
// throw whatever error, due to unexpected dispatched type
}
result_type operator()(OutgoingHeader const& h)
{
// handle OutgoingHeader
ctx_.do_smth_with_outgoing_header(h);
}
result_type operator()(IncomingHeader const& h)
{
// handle IncomingHeader
ctx_.do_smth_with_incoming_header(h);
}
private:
some_context& ctx_;
};
my_header_visitor v{/* pass context here */};
message_header h {/* some init code here */};
boost::apply_visitor(v, h);

附言：如果你有兴趣了解为什么需要变体或调度是如何工作的，你可以阅读安德烈·亚历山德雷斯库在多布斯博士中关于歧视工会的系列文章：

• 受歧视的工会(一)
• 受歧视的工会(二)
• 通用：受歧视的工会(三)

在解码过程中的某个时候，我需要一个 get_header() 函数来返回标头成员(incoming_header 或 outgoing_header)。

您不需要统一的签名，因此，这很容易：

住在科里鲁

IncomingHeader const& get_header(X_1 const& msg) { return msg.incoming_header; }
OutgoingHeader const& get_header(A_1 const& msg) { return msg.outgoing_header; }

使用它：

int main() {
X_1 x;
A_1 a;
// in your decode function:    
{
IncomingHeader const& h = get_header(x);
}
{
OutgoingHeader const& h = get_header(a);
}    
}

使其通用

因此，您不必为每种消息类型添加重载：

住在科里鲁

template <typename T> auto get_header(T&& msg) -> decltype((msg.incoming_header)) { return msg.incoming_header; }
template <typename T> auto get_header(T&& msg) -> decltype((msg.outgoing_header)) { return msg.outgoing_header; }

您可以将其用于任何声明的类型：

struct X_1 { IncomingHeader incoming_header; };
struct Y_2 { IncomingHeader incoming_header; };
struct Z_x { IncomingHeader incoming_header; };
//or Outgoing :
struct A_1 { OutgoingHeader outgoing_header; };
struct B_2 { OutgoingHeader outgoing_header; };
struct C_x { OutgoingHeader outgoing_header; };
template <typename T>
void decode(T&& msg) {
auto&& header = get_header(msg);
std::cout << typeid(T).name() << " has " << typeid(header).name() << "n";
}
int main() {
X_1 x;
A_1 a;
decode(x);
decode(a);
decode(Y_2{});
decode(Z_x{});
decode(B_2{});
decode(C_x{});
}

哪些打印

X_1 has IncomingHeader
A_1 has OutgoingHeader
Y_2 has IncomingHeader
Z_x has IncomingHeader
B_2 has OutgoingHeader
C_x has OutgoingHeader

实际上，您可以像以下那样使用时髦的消息类型：

struct Funky { std::map<std::string, std::string> outgoing_header; };

它会打印

Funky has std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >

(在科利鲁直播时看到这一切)

关于获取特定标头 (A&，B&)

您可以拥有更简单的界面：

template <typename T> auto get_header(T&& msg) -> decltype((msg.incoming_header)) { return msg.incoming_header; }
template <typename T> auto get_header(T&& msg) -> decltype((msg.outgoing_header)) { return msg.outgoing_header; }
struct A {};
struct B {};
template <typename T> A const& getHeaderA(T const& msg) { return get_header(msg).a; }
template <typename T> B const& getHeaderB(T const& msg) { return get_header(msg).b; }

这消除了类型差异：

template <typename T>
void decode(T&& msg) {
A const& headerA = getHeaderA(msg);
B const& headerB = getHeaderB(msg);
}

再次在科里鲁现场观看

由于 C++ 是一种静态类型语言，因此必须通过相同的类型返回两者。由于您只对标头结构的a和b成员感兴趣，因此一个明显的解决方案是使用从BaseHeader派生的IncomingHeader和OutgoingHeader，然后返回指向该基的引用或指针。

struct BaseHeader
{
A a;
B b;
};
struct IncomingHeader : BaseHeader
{
/* ... */
} incoming_header;
struct OutgoingHeader : BaseHeader
{
/* ... */
} outgoing_header;
BaseHeader const&get_header() const
{
if(/* ... */) return incoming_header;
return outgoing_header;
}