Как установить определенные биты?

Есть (по крайней мере) два основных подхода. Можно было бы создать структуру с некоторыми битовыми полями:

struct bits { 
    unsigned a : 1;
    unsigned b : 7;
    unsigned c : 4;
    unsigned d : 3;
    unsigned e : 1;
};

bits b;

b.a = val1;
b.b = val2;
b.c = val3;
b.d = val4;
b.e = val5;

Чтобы получить 16-битное значение, вы можете (например) создать объединение этой структуры с uint16_t. Только одна небольшая проблема: стандарт не гарантирует, в каком порядке окажутся битовые поля, когда вы посмотрите на 16-битное значение. Просто, например, вам может понадобиться изменить порядок, который я дал выше, чтобы получить порядок от наиболее значимых до наименее значимых битов, которые вам действительно нужны (но смена компилятора может снова все испортить).

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

int16_t result = val1 | (val2 << 1) | (val3 << 8) | (val4 << 12) | (val5 << 15);

На данный момент я предположил, что каждый из входных данных начинается в правильном диапазоне (т. е. имеет значение, которое может быть представлено в выбранном количестве бит). Если есть вероятность, что это может быть неправильно, вы должны сначала замаскировать его до правильного количества битов. Обычный способ сделать это примерно так:

uint16_t result = input & ((1 << num_bits) - 1);

Если вам интересна математика, она работает следующим образом. Предположим, мы хотим гарантировать, что ввод умещается в 4 бита. Сдвиг 1 влево на 4 бита дает 00010000 (в двоичном формате). Вычитание из него единицы затем очищает один установленный бит и устанавливает все менее значимые биты, что дает 00001111 для нашего примера. Это дает нам набор первых наименее значащих битов. Когда мы делаем побитовое AND между этим и входными данными, любые старшие биты, которые были установлены во входных данных, очищаются в результате.

Одним из решений было бы установить K-битное значение, начинающееся с N-го бита field, как:

uint16_t value_mask = ((1<<K)-1) << N; // for K=4 and N=3 will be 00..01111000
field = field & ~value_mask; // zeroing according bits inside the field
field = field | ((value << N) & value_mask); // AND with value_mask is for extra safety

Или, если вы можете использовать struct вместо uint16_t, вы можете использовать битовые поля и позволить компилятору выполнять все эти действия за вас.

Для этого можно использовать побитовые операторы или и сдвиг.

Используйте сдвиг << для «перемещения байтов влево»:

int i = 1;  // ...0001
int j = i << 3 // ...1000

Затем вы можете использовать побитовое или |, чтобы поместить его в нужное место (при условии, что у вас есть все нули в битах, которые вы пытаетесь перезаписать).

int k = 0;  // ...0000
k |= i // ...0001
k |= j // ...1001

Изменить: обратите внимание, что ответ @Inspired также объясняет обнуление определенной области битов. В целом это объясняет, как вы будете правильно его реализовывать.

попробуйте этот код:

uint16_t shift(uint16_t num, int shift)
{
    return num | (int)pow (2, shift);
}

где shift - это позиция бита, которую вы хотите установить