Как извлечь значения из структуры C++ с помощью битовых полей

Я могу придумать несколько способов, как это можно сделать, самый простой — использовать битовые поля непосредственно в вашей структуре:

struct X {
   uint32_t A : 4; // 4 bits for A. 
   uint32_t B : 4; 
   uint32_t C : 4; 
   uint32_t D : 4; 
   uint8_t E : 7; 
   uint8_t F : 1;
};

Затем вы можете легко получить или установить значения, используя, например:

X x;
x.A = 0xF;

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

Как указано в комментариях, фактическое поведение битовых полей может зависеть от вашей платформы, поэтому, если пространство имеет существенное значение, вы должны убедиться, что оно ведет себя так, как вы ожидаете. Также см. здесь дополнительную информацию о битовых полях в C++.

Я еще немного покопаюсь в битовых полях:

Ваша структура X остается неизменной:

struct X
{
    uint8_t fieldAB;
    uint8_t fieldCDE;
    uint8_t fieldFGH;
};

Давайте определим союз для легкого перевода:

union Xunion {
    X x;
    struct Fields { // Named in case you need to sizeof() it
        uint8_t A   : 4;
        uint8_t B   : 4;

        uint8_t C   : 2;
        uint8_t D   : 3;
        uint8_t E   : 3;

        uint8_t F   : 2;
        uint8_t G   : 3;
        uint8_t H   : 3;
    };
};

И теперь вы можете легко получить доступ к этим битовым полям.

Прежде чем кто-нибудь попытается содрать с меня кожу, обратите внимание, что это никоим образом не является переносимым и даже не определено стандартом C++. Но он будет делать то, что вы ожидаете от любого здравомыслящего компилятора.

Вы можете добавить специфичную для компилятора директиву упаковки (например, __attribute__((packed)) GCC) в структуру Fields, а также static_assert, гарантирующую, что sizeof оба члена объединения строго равны.

Лучше всего, IMO, вообще забыть об использовании структуры или, если это так, использовать объединение структуры и массива байтов. Затем ваши функции доступа используют массив байтов, для которого легко вычислить смещения и так далее. Делая это, я считаю, что вы гарантированно получите доступ к нужным вам байтам.

Недостатком является то, что вам придется повторно собирать 16- и 32-битные значения, если таковые имеются, найденные в структуре, и делать это с учетом любых проблем с порядком байтов. Если вы знаете, что любые такие значения находятся на границах 16- или 32-битных адресов, вы можете использовать объединенные короткие и длинные массивы, чтобы сделать это, что, вероятно, было бы лучше, хотя и несколько непрозрачно.

ХТН

Может быть, я нашел решение. Я могу создать API следующим образом:

uint8_t getValue(valueTypeEnum typeOfValue, X * data)
{
    uint8_t bitmask;
    uint8_t * field = getBitmaskAndFieldPtr(typeOfValue, data, &bitmask);

    return ((*field) & bitmask) >> ...;
}

void setValue(valueTypeEnum typeOfValue, X * data, uint8_t value)
{
    uint8_t bitmask;
    uint8_t * field = getBitmaskAndFieldPtr(typeOfValue, data, &bitmask);

    *field = ((*field) & !bitmask) | (value << ...);
}

uint8_t * getBitmaskAndFieldPtr(valueTypeEnum typeOfValue, X * data, uint8_t * bitmask)
{
    uint8_t * fieldPtr = 0;

    switch(typeOfValue)
    {
         case A:
         {
               *bitmask = 0x0F; // I can use also a dictionary here
               fieldPtr = &data.AB;
               break;
         }
         case B:
         {
               *bitmask = 0xF0; // I can use also a dictionary here
               fieldPtr = &data.AB;
               break;
         }
         case C:
         {
               *bitmask = 0xC0; // I can use also a dictionary here
               fieldPtr = &data.CDE;
               break;
         }
         ...    
    }

    return fieldPtr;
}

Я знаю, что switch-case не так элегантен и требует обновления каждый раз при изменении структуры, но я не вижу автоматического способа (возможно, с использованием отражения) решить эту проблему.