C ++ массивы переменной длины в структуре

Короткий ответ: вы просто не можете иметь типы переменного размера в 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ответ должен работать так же быстро, как и это внутренняя сторона.