использование побитовых операторов для упаковки нескольких значений в один int

Более сжатый ответ:

ААААААА Г ЧХХХХХХ

Упаковка:

packed = age << 8 | gender << 7 | height

В качестве альтернативы вы можете просто суммировать компоненты, если, например, при использовании в агрегатной функции MySQL SUM.

packed = age << 8 + gender << 7 + height

Распаковка:

age = packed >> 8 // no mask required
gender = packed >> 7 & ((1 << 1) - 1) // applying mask (for gender it is just 1)
height = packed & ((1 << 7) - 1) // applying mask

Еще один (длинный) пример:

Допустим, у вас есть IP-адрес, который вы хотите упаковать, однако это вымышленный IP-адрес, например, 132.513.151.319. Обратите внимание, что некоторые компоненты больше 256, что требует более 8 бит, в отличие от реальных IP-адресов.

Сначала нам нужно выяснить, какое смещение нам нужно использовать, чтобы иметь возможность хранить максимальное число. Допустим, с нашими вымышленными IP-адресами ни один компонент не может быть больше 999, что означает, что нам нужно 10 бит памяти на компонент (допускается число до 1014).

packed = (comp1 << 0 * 10) | (comp1 << 1 * 10) | (comp1 << 2 * 10) | (comp1 << 3 * 10)

Что дает dec 342682502276 или bin 100111111001001011110000000010010000100

Теперь давайте распакуем значение

comp1 = (packed >> 0 * 10) & ((1 << 10) - 1) // 132
comp2 = (packed >> 1 * 10) & ((1 << 10) - 1) // 513
comp3 = (packed >> 2 * 10) & ((1 << 10) - 1) // 151
comp4 = (packed >> 3 * 10) & ((1 << 10) - 1) // 319

Где (1 << 10) - 1 — это двоичная маска, которую мы используем, чтобы скрыть биты слева за пределами 10 правых битов, которые нас интересуют.

Тот же пример с использованием запроса MySQL

SELECT

(@offset := 10) AS `No of bits required for each component`,
(@packed := (132 << 0 * @offset) | 
            (513 << 1 * @offset) | 
            (151 << 2 * @offset) | 
            (319 << 3 * @offset)) AS `Packed value (132.513.151.319)`,

BIN(@packed) AS `Packed value (bin)`,

(@packed >> 0 * @offset) & ((1 << @offset) - 1) `Component 1`,
(@packed >> 1 * @offset) & ((1 << @offset) - 1) `Component 2`,
(@packed >> 2 * @offset) & ((1 << @offset) - 1) `Component 3`,
(@packed >> 3 * @offset) & ((1 << @offset) - 1) `Component 4`;

Оператор сдвига влево означает «умножить на два столько раз». В двоичном формате умножение числа на два равносильно добавлению нуля к правой части.

Оператор сдвига вправо является обратным оператору сдвига влево.

Оператор канала — «или», что означает наложение двух двоичных чисел друг на друга, и если в любом числе есть 1, результатом в этом столбце будет 1.

Итак, давайте извлечем операцию для pack_info:

// Create age, shifted left 8 times:
//     AAAAAAA00000000
age_shifted = age << 8;

// Create gender, shifted left 7 times:
//     0000000G0000000
gender_shifted = gender << 7;

// "Or" them all together:
//     AAAAAAA00000000
//     0000000G0000000
//     00000000HHHHHHH
//     ---------------
//     AAAAAAAGHHHHHHH
packed_info = age_shifted | gender_shifted | height;

А распаковка обратная.

// Grab the lowest 7 bits:
//     AAAAAAAGHHHHHHH &
//     000000001111111 =
//     00000000HHHHHHH
height = packed_info & 0x7F;

// right shift the 'height' bits into the bit bucket, and grab the lowest 1 bit:
//     AAAAAAAGHHHHHHH 
//   >> 7 
//     0000000AAAAAAAG &
//     000000000000001 =
//     00000000000000G
gender = (packed_info >> 7) & 1;

// right shift the 'height' and 'gender' bits into the bit bucket, and grab the result:
//     AAAAAAAGHHHHHHH 
//   >> 8
//     00000000AAAAAAA
age    = (packed_info >> 8);

С таким же требованием я сталкивался много раз. Это очень легко сделать с помощью побитового оператора AND. Просто уточните свои значения с возрастающими степенями двойки (2). Чтобы сохранить несколько значений, ДОБАВЬТЕ их относительное число ( степень 2 ) и получите СУММУ. Эта СУММА объединит выбранные вами значения. КАК ?

Просто выполните побитовое И с каждым значением, и оно даст ноль (0) для значений, которые не были выбраны, и ненулевых для тех значений, которые выбраны.

Вот объяснение:

1) Ценности (ДА, НЕТ, МОЖЕТ БЫТЬ)

2) Присвоение степени двойки(2)

YES   =    2^0    =    1    =    00000001
NO    =    2^1    =    2    = 00000010
MAYBE =    2^2    =    4    = 00000100

3) Я выбираю ДА и МОЖЕТ БЫТЬ, следовательно, СУММА:

SUM    =    1    +    4    =    5

SUM    =    00000001    +    00000100    =    00000101 

Это значение будет хранить как YES, так и MAYBE. КАК?

1    &    5    =    1    ( non zero )

2    &    5    =    0    ( zero )

4    &    5    =    4    ( non zero )

Следовательно, SUM состоит из

1    =    2^0    =    YES
4    =    2^2    =    MAYBE.

Для более подробного объяснения и реализации посетите мой блог

Вы можете рассматривать выражение x & mask как операцию, удаляющую из x биты, которые отсутствуют (т. е. имеют значение 0) в mask. Это означает, что packed_info & 0x7F удаляет из packed_info все биты старше седьмого бита.

Пример: если packed_info равно 1110010100101010 в двоичном формате, то packed_info & 0x7f будет

1110010100101010
0000000001111111
----------------
0000000000101010

Итак, в height мы получаем младшие 7 бит packed_info.

Далее сдвигаем все packed_info на 7, таким образом убираем информацию, которую уже считывали. Таким образом, мы получаем (для значения из предыдущего примера) 111001010 Пол сохраняется в следующем бите, поэтому с тем же приемом: & 1 мы извлекаем из информации только этот бит. Остальная информация содержится по смещению 8.

Обратная упаковка также не сложна: вы берете age, сдвигаете его на 8 бит (так что вы получаете 1110010100000000 из 11100101), сдвигаете gender на 7 (так что вы получаете 00000000) и берете высоту (при условии, что она будет соответствовать младшим 7 битам) . Затем вы составляете их все вместе:

1110010100000000
0000000000000000
0000000000101010
----------------
1110010100101010