结构中的C++可变长度数组

您想要一个相当低级别的东西，一个ARP数据包，并且您正试图找到一种方法来正确定义数据结构，以便将blob投射到该结构中。相反，您可以在blob上使用一个接口。

struct ArpHeader {
    mutable std::vector<uint8_t> buf_;
    template <typename T>
    struct ref {
        uint8_t * const p_;
        ref (uint8_t *p) : p_(p) {}
        operator T () const { T t; memcpy(&t, p_, sizeof(t)); return t; }
        T operator = (T t) const { memcpy(p_, &t, sizeof(t)); return t; }
    };
    template <typename T>
    ref<T> get (size_t offset) const {
        if (offset + sizeof(T) > buf_.size()) throw SOMETHING;
        return ref<T>(&buf_[0] + offset);
    }
    ref<uint16_t> hwType() const { return get<uint16_t>(0); }
    ref<uint16_t> protType () const { return get<uint16_t>(2); }
    ref<uint8_t> hwAddrLen () const { return get<uint8_t>(4); }
    ref<uint8_t> protAddrLen () const { return get<uint8_t>(5); }
    ref<uint16_t> opCode () const { return get<uint16_t>(6); }
    uint8_t *senderHwAddr () const { return &buf_[0] + 8; }
    uint8_t *senderProtAddr () const { return senderHwAddr() + hwAddrLen(); }
    uint8_t *targetHwAddr () const { return senderProtAddr() + protAddrLen(); }
    uint8_t *targetProtAddr () const { return targetHwAddr() + hwAddrLen(); }
};

如果需要const的正确性，则删除mutable，创建一个const_ref，并将访问器复制到非const版本中，并使const版本返回const_ref和const uint8_t *。

简单回答：在C++中不能有可变大小的类型。

在编译过程中，C++中的每个类型都必须具有已知（且稳定）的大小。IE运算符sizeof()必须给出一致的答案。注意，您可以通过使用堆来拥有保存可变数据量的类型（例如：std::vector<int>），但实际对象的大小始终是恒定的。

因此，您永远无法生成一个类型声明，您可以强制转换并神奇地调整字段。这深入到了基本的对象布局中——每个成员（也称为字段）都必须有一个已知的（稳定的）偏移。

通常，通过编写（或生成）解析输入数据并初始化对象数据的成员函数来解决问题。这基本上是一个由来已久的数据序列化问题，在过去30年左右的时间里，这个问题已经解决了无数次。

以下是一个基本解决方案的模型：

class packet { 
public:
    // simple things
    uint16_t hardware_type() const;
    // variable-sized things
    size_t sender_address_len() const;
    bool copy_sender_address_out(char *dest, size_t dest_size) const;
    // initialization
    bool parse_in(const char *src, size_t len);
private:    
    uint16_t hardware_type_;    
    std::vector<char> sender_address_;
};

注：

• 上面的代码显示了一个非常基本的结构，可以让您执行以下操作：

  packet p;
  if (!p.parse_in(input, sz))
      return false;
  

• 通过RAII做同样事情的现代方式看起来是这样的：

  if (!packet::validate(input, sz))
      return false;
  packet p = packet::parse_in(input, sz);  // static function 
                                           // returns an instance or throws
  

如果您想保持对数据的简单访问以及数据本身public，有一种方法可以在不更改访问数据的方式的情况下实现您想要的内容。首先，您可以使用std::string而不是char数组来存储地址：

#include <string>
using namespace std; // using this to shorten notation. Preferably put 'std::'
                     // everywhere you need it instead.
struct ArpHeader
{
    unsigned char hardwareAddressLength;
    unsigned char protocolAddressLength;
    string senderHardwareAddress;
    string senderProtocolAddress;
    string targetHardwareAddress;
    string targetProtocolAddress;
};

然后，您可以重载转换运算符operator const char*()和构造函数arpHeader(const char*)（当然最好也是operator=(const char*)），以便保持当前的发送/接收函数正常工作（如果需要的话）。

一个简化的转换运算符（跳过了一些字段，使其不那么复杂，但您应该可以将它们添加回来），看起来是这样的：

operator const char*(){
    char* myRepresentation;
    unsigned char mySize
            = 2+ senderHardwareAddress.length()
            + senderProtocolAddress.length()
            + targetHardwareAddress.length()
            + targetProtocolAddress.length();
    // We need to store the size, since it varies
    myRepresentation = new char[mySize+1];
    myRepresentation[0] = mySize;
    myRepresentation[1] = hardwareAddressLength;
    myRepresentation[2] = protocolAddressLength;
    unsigned int offset = 3; // just to shorten notation
    memcpy(myRepresentation+offset, senderHardwareAddress.c_str(), senderHardwareAddress.size());
    offset += senderHardwareAddress.size();
    memcpy(myRepresentation+offset, senderProtocolAddress.c_str(), senderProtocolAddress.size());
    offset += senderProtocolAddress.size();
    memcpy(myRepresentation+offset, targetHardwareAddress.c_str(), targetHardwareAddress.size());
    offset += targetHardwareAddress.size();
    memcpy(myRepresentation+offset, targetProtocolAddress.c_str(), targetProtocolAddress.size());
    return myRepresentation;
}

而构造函数可以这样定义：

ArpHeader& operator=(const char* buffer){
    hardwareAddressLength = buffer[1];
    protocolAddressLength = buffer[2];
    unsigned int offset = 3; // just to shorten notation
    senderHardwareAddress = string(buffer+offset, hardwareAddressLength);
    offset += hardwareAddressLength;
    senderProtocolAddress = string(buffer+offset, protocolAddressLength);
    offset += protocolAddressLength;
    targetHardwareAddress = string(buffer+offset, hardwareAddressLength);
    offset += hardwareAddressLength;
    targetProtocolAddress = string(buffer+offset, protocolAddressLength);
    return *this;
}
ArpHeader(const char* buffer){
    *this = buffer; // Re-using the operator=
}

然后使用你的类很简单：

ArpHeader h1, h2;
h1.hardwareAddressLength = 3;
h1.protocolAddressLength = 10;
h1.senderHardwareAddress = "foo";
h1.senderProtocolAddress = "something1";
h1.targetHardwareAddress = "bar";
h1.targetProtocolAddress = "something2";
cout << h1.senderHardwareAddress << ", " << h1.senderProtocolAddress
<< " => " << h1.targetHardwareAddress << ", " << h1.targetProtocolAddress << endl;
const char* gottaSendThisSomewhere = h1;
h2 = gottaSendThisSomewhere;
cout << h2.senderHardwareAddress << ", " << h2.senderProtocolAddress
<< " => " << h2.targetHardwareAddress << ", " << h2.targetProtocolAddress << endl;
delete[] gottaSendThisSomewhere;

它应该为您提供所需的实用程序，并在不更改类外任何内容的情况下保持代码的工作。

然而，请注意，如果您愿意稍微更改代码的其余部分（在这里谈论您已经编写的代码，在类的其他部分），jxh的答案应该和这个一样快，并且在内部更优雅。