Упрощение работы с динамическими структурами в C++

Часто приходится иметь дело с динамическими структурами и обменом ими через сокеты и т.п.

Вообще я максимально стараюсь использовать при обмене только структуры фиксированного размера, а если что-то шибко большое или заранее неизвестного размера, то лучше предусмотреть этот случай вводом дополнительных флагов типа начало/конец и отправить несколько пакетов.

Трудности начинаются, когда всё же необходимо иметь структуры с динамическим размером, а точнее, когда в этой структуре есть несколько элементов с динамическим размером.
Что бы их создавать/парсить обычно объявляется примерно так:

struct MyStruct1 { //-- First dynamic struct for example
  double d1;
  int fixed1;
  char dynamicStr1[]; //-- dynamic data
}

Здесь только один элемент с динамическим размером — dynamicStr[], можно сказать проблем нет, т.к. вполне ясно и понятно что в структуре и можно легко достать.

Когда появляется необходимость во втором, третьем, N, то так как в структуре может быть лишь один элемент с динамическим размером (flexible array member), то в нём придётся хранить все структуры с динамическим размером, а потом, при разборе, доставать.
Примерно так:

stryct MyStructU {
  size_t sizeStruct1; //-- Либо можно использовать offset, суть та же
  size_t sizeStruct2;
  size_t sizeStruct3;
  char payloadStruct1Struct2Struct3[0];
}
....
MyStructU *myStructU = (MyStructU *)malloc(sizeof(MyStructU *)+sizeStruct1+sizeStruct2+sizeStruct3);
...
MyStruct3 *myStruct3 = ((uint8_t)myStructU+myStructU.sizeStruct1+myStructU.sizeStruct2);

Мне это не нравится тем, что

Фактически типы динамических элементов известны лишь косвенно (из комментариев или названий их размеров).
Для использования элемента динамического типа необходимо каждый раз использовать адресную арифметику.
Теряется смысл структуры как таковой и превращается в обычный линейный массив.
Необходимость выведения правильных размеров

Я бы конечно предпочёл как наиболее разумное это написание класса с геттерами/сеттерами для таких структур, НО т.к. попался проект с большим количеством таких мелких структур, то решил попробовать сделать универсальный и удобный в использовании класс.

Требования к нему были такие:

Не менять исходную структуру, которая используется при обмене.
Фактически используемые типы должны быть явно объявлены в заголовочных файлах и IDE могла отследить не только их, но и элементы базовой структуры.
Без необходимости явно указывать размеры динамических структур (только размер их динамических данных)
Возможность получение линейного последовательного буфера и полного размера, а так же работа из него без копирования.

Так как менять структуру нельзя, а динамические элементы должны быть объявлены явно,
то лучшим решением мне показалось создавать отдельную структуру — «реализацию».
Что бы было явно видно для чего эта структура, то нужно сразу при объявлении унаследоваться от нашего класса, а что бы наш класс знал, какие типы используются придётся его сделать шаблонным.

MyStructUImpl: DynamicStruct<MyStructU, DynamicMember<MyStruct1, &MyStructU::sizeMyStruct1>, DynamicMember<MyStruct2, &MyStructU::sizeMyStruct2>, DynamicMember<MyStruct3, &MyStructU::sizeMyStruct3>>  {
  MyStruct1  *myStruct1;
  MyStruct2  *myStruct2;
  MyStruct3  *myStruct3;
}

Такая структура по использованию вырисовывается.

Принцип то в общем прост: должны будем в конструкторе создать линейный массив по размеру динамических структур (т.е. по размеру их самих + размер их динамических данных), и указателям задать адрес где будет начинаться очередная динамическая структура в массиве. Разумеется, саму базовую структуру то же нужно первым делом.
Что бы был доступ к базовой структуре перегрузим оператор указателя.

В итоге для взаимодействий использовать будем только MyStructUImpl, а базовая MyStructU остаётся только для передач по сокетам и т.п.

Полный готовый листинг класса DynamicStruct:

 #ifndef DYNAMICSTRUCT_H
#define DYNAMICSTRUCT_H

#include <cstddef>
#include <cstdint>
#include <stdexcept>

template <typename T, typename MemberType>
static size_t offsetof2(MemberType T::*member) { return reinterpret_cast<size_t>(&(reinterpret_cast<T*>(0)->*member)); }

template<typename T, typename M>
static T getClassType(M T::*);  //  template<auto Ptr> f() { decltype(getClassType(Ptr)); }

#pragma pack(push, 1)
/**
* @brief Класс динамического элемента структуры
* @param Type - Тип элемента
* @param SizePtr - Указатель на элемент, в котором хранится размер этого динамического элемента
*/
template <typename Type, auto SizePtr>
struct DynamicMember {
  using type =Type;
  static constexpr size_t size =sizeof(Type);
  static constexpr decltype(SizePtr) sizePtr =SizePtr;
};

/**
* @brief Сахар для работы с динамическими структурами
* @param Base - Тип базовой структуры
* @param DynamicMembers... - Список динамических элементов в базовой (DynamicMember<Type, &Base::sizeMember>)
* @example
*
* #pragma pack(push, 1)
* struct MyStruct1 { //-- First dynamic struct for example
*   int a1;
*   char dynamicStr1[]; //-- dynamic data
* }
*
* struct MyStruct2 { //-- Second dynamic struct for example
*   double d2;
*   int fixed2;
*   char dynamicStr2[]; //-- dynamic data
* }
*
* struct MyBase {
*   size_t sizeMyStruct1;
*   size_t sizeMyStruct2;
*   int fixedVal;
*   double fixedMore;
*   char fixedStr[20];
*   uint8_t data[0]; //-- MyStruct1, MyStruct2;
* }
*
* struct MyBaseImp: DynamicStruct<MyBase, DynamicMember<MyStruct1, &MyBase::sizeMyStruct1>, DynamicMember<MyStruct2, &MyBase::sizeMyStruct2>>  {
*   MyStruct1 *myStruct1; //-- Pointer! Do not initialize!
*   MyStruct2 *myStruct2; //-- Pointer! Do not initialize!
* }
* #pragma pack(pop)
*
*
* char *str1 ="DynamicStr1";
* size_t str1Len =strlen(str1);
*
* char *str2 ="Privet,Medved";
* size_t str2Len =strlen(str2);
*
* MyBaseImp myBaseImp={{str1Len, str2Len}};
* myBaseImp->fixedVal =12345;
* myBaseImp->fixedMore =13.30;
* myBaseImp.myStruct1->a1 = 42;
* myBaseImp.myStruct2->d2 = 19.02;
* snprintf(myBaseImp.myStruct1->dynamicStr1, str1Len, str1);
* snprintf(myBaseImp.myStruct2->dynamicStr2, str2Len, str2);
* ...
* socketSend(myBaseImp.buf(), myBaseImp.size());
* ...
* ...
* socketReceive(buf);
* ...
* MyBaseImp myBaseImpRec ={{(uint8_t*)buf}};
* printf(myBaseImpRec.myStruct1->dynamicStr1);
*
* @author 2me@pavelk.ru
*/
template <typename Base, typename ...DynamicMembers>
class DynamicStruct {
public:
  /**
  * @brief Создаём новую
  * @param extraSizeValues - размер дополнительных данных
  */
  template<typename ...DynamicMemberDataSizes>
  DynamicStruct(DynamicMemberDataSizes... dynamicMemberDataSizes)
  {
    _bufSize =sizeof(Base)+(sizeof(DynamicMembers)+...)+sum(dynamicMemberDataSizes...);
    _buf =new uint8_t[_bufSize];
    _bufIsSelf =true;
    initDynamicMembers<DynamicMembers...>(0, sizeof(Base), dynamicMemberDataSizes...);
  }

  /**
  * @brief Создаём новую с нулевым размером дополнительных данных
  */
  DynamicStruct()
  {
    _bufSize =(sizeof(DynamicMembers)+...);
    _buf =new uint8_t[_bufSize];
    _bufIsSelf =true;
    initDynamicMembers<DynamicMembers...>(0, sizeof(Base), 0);
  }

  /**
  * @brief Создаём из существующего буфера
  * @param data
  */
  DynamicStruct(uint8_t *data)
  {
    if ( data==nullptr ) { throw std::logic_error("Data is nullptr"); }
    _bufIsSelf =false;
    _buf =data;
    const size_t minSize =(sizeof(DynamicMembers)+...);
    const size_t typesSize =loadDynamicMembers<DynamicMembers...>(0, sizeof(Base));
    //-- Убедимся, что сумма заданных размеров динамических типов не меньше, чем размер самих типов
    if ( typesSize<minSize ) { throw std::logic_error("The specified size in data is smaller than the minimum size of the DynamicMembers"); }
    _bufSize =sizeof(Base)+typesSize;
  }

   /**
  * @brief
  */
  ~DynamicStruct()
  {
    if ( _bufIsSelf && _buf!=nullptr ) { delete []_buf; _buf =nullptr;}
    _bufSize =0;
  }

  /**
  * @brief Отдаём основную структуру
  * @return
  */
  Base *operator->() { return reinterpret_cast<Base*>(_buf); }

  /**
  * @brief Отдаём полный размер
  * @return
  */
  size_t size() const { return _bufSize; }

  /**
  * @brief Отдаём буфер с данными
  * @return
  */
  uint8_t *buf() const { return _buf; }

private:
  uint8_t *_buf =nullptr; //-- Память для хранения как последовательный набор байт
  size_t _bufSize =0; //-- Размер буфера
  bool _bufIsSelf =true; //-- Буфер создан нами, и освобождаем мы же

  /**
  * @brief Суммируем значения типов
  * @param args
  * @return
  */
  template<typename ...Args>
  size_t sum(Args&&... args) { return (args+...); }

   /**
  * @brief Инициализируем из нового буфера
  * @param idx - Индекс динамического элемента базовой структуры
  * @param offset - Смещение в buf на котором закончился предыдущий динамический элемент (его размер+размер дополнительных данных)
  * @param dynamicMemberDataSize - Размер динамических данных обрабатываемого динамического элемента
  * @param OtherDynamicMemberDataSize - Оставшиеся размеры динамических данных динамического элемента
  */
  template <typename TDynamicMember, typename ...OtherDynamicMembers, typename DynamicMemberDataSize, typename ...OtherDynamicMemberDataSize>
  void initDynamicMembers(size_t idx, size_t offset, DynamicMemberDataSize dynamicMemberDataSize,  OtherDynamicMemberDataSize ...otherDynamicMemberDataSize)
  {
    //-- Получаем указатель на тип динамического элемент
    typename TDynamicMember::type *dynamicMember =reinterpret_cast<decltype(dynamicMember)>(_buf+offset);
    //-- Находим итоговый размер динамического элементе
    const size_t memberFullSize =TDynamicMember::size+dynamicMemberDataSize;
    //-- Устанавливаем указатель на структуру в реализации
    *((void **)(reinterpret_cast<uint8_t*>(this+1)+sizeof(void*)*idx)) =dynamicMember;
    //-- Устанавливаем размер по указанному адресу, указанному в динамическом элементе
    *(&(reinterpret_cast<decltype(getClassType(TDynamicMember::sizePtr))*>(_buf)->*TDynamicMember::sizePtr)) =memberFullSize;
    //-- Обрабатываем остальные динамические элементы
    if constexpr( sizeof...(OtherDynamicMembers)>0 ) {
      if constexpr( sizeof...(otherDynamicMemberDataSize)>0 ) { //-- Если задан размер динамических данных
        initDynamicMembers<OtherDynamicMembers...>(idx+1, offset+memberFullSize, otherDynamicMemberDataSize...);
      } else { //-- Не задан размер динамических данных, значит считаем, что элемент фиксированного размера
        initDynamicMembers<OtherDynamicMembers...>(idx+1, offset+memberFullSize, 0);
      }
    }
  }

  /**
  * @brief Инициализируем из существующего буфера
  * @param idx
  * @param offset
  * @return Сумма размеров динамических типов
  */
  template <typename TDynamicMember, typename ...OtherDynamicMembers>
  size_t loadDynamicMembers(size_t idx, size_t offset)
  {
    //-- Получаем итоговый размер динамического элемента
    const size_t typeFullSize =reinterpret_cast<decltype(getClassType(TDynamicMember::sizePtr))*>(_buf)->*TDynamicMember::sizePtr;
    //-- Устанавливаем указатель на структуру в нашей
    *((void **)(reinterpret_cast<uint8_t*>(this+1)+sizeof(void*)*idx)) =(_buf+offset);
    //-- Обрабатываем остальные типы
    if constexpr( sizeof...(OtherDynamicMembers)>0 ) {
      return typeFullSize +loadDynamicMembers<OtherDynamicMembers...>(idx+1, offset+typeFullSize);
    }
    return typeFullSize;
  }

};
#pragma pack(pop)


#endif

Использовать просто:

MyStructUImpl  myStructUImpl={{10, 20, 20}}; //-- Создаём новую и задаём размеры динамических структур


MyStructUImpl  myStructUImplFromBuf={{(uint8_t*)buf}}; //-- Создаём из существующего буфера

Вот как-то так =)

сетевой обмен

Упрощение работы с динамическими структурами в C++

Leave a Comment Cancel Reply

OpenCV — Rotate Text

You may also like