У меня есть 8 переменных bool, и я хочу "объединить" их в байт.
Есть ли простой/предпочтительный метод для этого?
Как насчет обратного пути, декодирование байта на 8 отдельных булевых значений?
Я предполагаю, что это не необоснованный вопрос, но поскольку я не мог найти соответствующую документацию через Google, возможно, это еще один случай из тех случаев, когда вы ошибаетесь.
Трудный путь:
unsigned char ToByte(bool b[8])
{
unsigned char c = 0;
for (int i=0; i < 8; ++i)
if (b[i])
c |= 1 << i;
return c;
}
и
void FromByte(unsigned char c, bool b[8])
{
for (int i=0; i < 8; ++i)
b[i] = (c & (1<<i)) != 0;
}
Или крутой способ:
struct Bits
{
unsigned b0:1, b1:1, b2:1, b3:1, b4:1, b5:1, b6:1, b7:1;
};
union CBits
{
Bits bits;
unsigned char byte;
};
Затем вы можете назначить одному члену союза и прочитать его. Но учтите, что порядок бит в Bits определяется реализацией.
Вы можете посмотреть std::bitset. Это позволяет вам компактно хранить логические элементы в виде битов со всеми операторами, которых вы ожидаете.
Нет смысла дурачиться с перевернутым битом и еще много чего, когда вы сможете отвлечься.
#include <stdint.h> // to get the uint8_t type
uint8_t GetByteFromBools(const bool eightBools[8])
{
uint8_t ret = 0;
for (int i=0; i<8; i++) if (eightBools[i] == true) ret |= (1<<i);
return ret;
}
void DecodeByteIntoEightBools(uint8_t theByte, bool eightBools[8])
{
for (int i=0; i<8; i++) eightBools[i] = ((theByte & (1<<i)) != 0);
}
inline uint8_t pack8bools(bool* a)
{
uint64_t t = *((uint64_t*)a);
return 0x8040201008040201*t >> 56;
}
void unpack8bools(uint8_t b, bool* a)
{
auto MAGIC = 0x8040201008040201ULL;
auto MASK = 0x8080808080808080ULL;
*((uint64_t*)a) = ((MAGIC*b) & MASK) >> 7;
}
Конечно, вам может потребоваться убедиться, что массив bool правильно выровнен на 8 байт, чтобы избежать снижения производительности и/или UB
Предположим, что у нас есть 8 bools b[0] до b[7], младшие значащие биты которых называются ah соответственно, которые мы хотим упаковать в один байт. Рассматривая эти 8 последовательных bool как одно 64-битное слово и загружая их, мы получим бит в обратном порядке в машине little-endian. Теперь мы сделаем умножение (здесь точки равны нулю)
| b7 || b6 || b4 || b4 || b3 || b2 || b1 || b0 |
.......h.......g.......f.......e.......d.......c.......b.......a
x 1000000001000000001000000001000000001000000001000000001000000001
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
↑......h.↑.....g..↑....f...↑...e....↑..d.....↑.c......↑b.......a
↑.....g..↑....f...↑...e....↑..d.....↑.c......↑b.......a
↑....f...↑...e....↑..d.....↑.c......↑b.......a
+ ↑...e....↑..d.....↑.c......↑b.......a
↑..d.....↑.c......↑b.......a
↑.c......↑b.......a
↑b.......a
a
▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬
= abcdefghxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Стрелки добавляются, поэтому легче видеть положение заданных бит в магическом числе. В этот момент в верхний байт помещено 8 наименее значимых бит, нам просто нужно будет замаскировать оставшиеся биты
Таким образом, магическое число для упаковки будет 0b1000000001000000001000000001000000001000000001000000001000000001 или 0x8040201008040201. Если вы находитесь на машине большого конца, вам нужно использовать магический номер 0x0102040810204080 который вычисляется аналогичным образом
Для распаковки мы можем сделать подобное умножение
| b7 || b6 || b4 || b4 || b3 || b2 || b1 || b0 |
abcdefgh
x 1000000001000000001000000001000000001000000001000000001000000001
__________________________________________________________________
= h0abcdefgh0abcdefgh0abcdefgh0abcdefgh0abcdefgh0abcdefgh0abcdefgh
& 1000000010000000100000001000000010000000100000001000000010000000
__________________________________________________________________
= h0000000g0000000f0000000e0000000d0000000c0000000b0000000a0000000
После умножения у нас есть необходимые биты в наиболее значимых положениях, поэтому нам нужно замаскировать нерелевантные биты и сдвинуть остатки на наименее значимые позиции. На выходе будут байты, содержащие a до h в маленьком конце.
Для новых процессоров x86 с BMI2 для этого есть инструкции PEXT и PDEP. Функция pack8bools выше может быть заменена на
_pext_u64(*((uint64_t*)a), 0x0101010101010101ULL);
И функция unpack8bools может быть реализована как
_pdep_u64(b, 0x0101010101010101ULL);
bool a,b,c,d,e,f,g,h;
//do stuff
char y= a<<7 | b<<6 | c<<5 | d<<4 | e <<3 | f<<2 | g<<1 | h;//merge
хотя вам, вероятно, лучше использовать битрейт
Невозможно упаковать 8 bool переменных в один байт. Существует способ упаковывать 8 логических истинно/ложных состояний в один байт, используя Bitmasking.
Вы должны использовать операцию побитового сдвига и кастинг для архивирования. функция может работать следующим образом:
unsigned char toByte(bool *bools)
{
unsigned char byte = \0;
for(int i = 0; i < 8; ++i) byte |= ((unsigned char) bools[i]) << i;
return byte;
}
Спасибо Кристиан Рау за исправление s!
Я хотел бы отметить, что тип punning через union является UB в С++ (как Rodrigo делает в его ответ. Самый безопасный способ сделать это memcpy()
struct Bits
{
unsigned b0:1, b1:1, b2:1, b3:1, b4:1, b5:1, b6:1, b7:1;
};
unsigned char toByte(Bits b){
unsigned char ret;
memcpy(&ret, &b, 1);
return ret;
}
Как говорили другие, компилятор достаточно умен, чтобы оптимизировать memcpy().
Кстати, это то, как Boost набирает punning.
Даже с C++ я использую этот заголовочный файл:
#ifndef __bit_h__
#define __bit_h__
#ifdef __cplusplus
#include <cstdint>
extern "C" {
#else
#include <stdint.h>
#endif
#ifndef BITWISE_OPERATIONS_TYPE
#define BITWISE_OPERATIONS_TYPE uint16_t
#endif
// gives a value with only the nth bit set
// usage: int flags = 10000b;
// bool enabled = (flags & BIT(4)) ? true : false; // result is true
#define BIT(n) (((BITWISE_OPERATIONS_TYPE) 1) << (n))
// gives the input with the nth bit set
// usage: flags = BIT_SET(flags, 3);
// result: flags = 0b11000
#define BIT_SET(in, n) (in | BIT(n))
// gives the input with the nth bit clear
// usage: flags = BIT_CLR(flags, 3);
// result: flags = 0b10000
#define BIT_CLR(in, n) (in & ~BIT(n))
// gives the nth bit only of the input
// usage: bool both_clr = !(BIT_GET(flags1, 3) & BIT_GET(flags2, 3));
// result: both_clr = true (lets say 'flags1, flags2 = 0, 0')
#define BIT_GET(in, n) (in & BIT(n))
// gives 1 if the nth bit of the input is set else gives 0
// usage: if(IS_BIT_SET(flags, 3)) { /*... it will not run */ }
#define IS_BIT_SET(in, n) (BIT_GET(in, n) > 0)
static inline BITWISE_OPERATIONS_TYPE bit(unint8_t n) {
return (((BITWISE_OPERATIONS_TYPE) 1) << n); }
static inline BITWISE_OPERATIONS_TYPE bit_set(BITWISE_OPERATIONS_TYPE in, unint8_t n) {
return (in | bit(n)); }
static inline BITWISE_OPERATIONS_TYPE bit_clr(BITWISE_OPERATIONS_TYPE in, unint8_t n) {
return (in & ~bit(n)); }
static inline BITWISE_OPERATIONS_TYPE bit_get(BITWISE_OPERATIONS_TYPE in, unint8_t n) {
return (in & bit(n)); }
static inline unint8_t is_bit_set(BITWISE_OPERATIONS_TYPE in, unint8_t n) {
return (bit_get(in, n) > 0); }
#ifdef __cplusplus
}
#endif
#endif // __bit_h__
Простой и понятный, без определений классов, и вы можете свободно изменять этот файл в соответствии с вашими потребностями... например, вы можете изменить uint16_t на uint32_t или на uint64_t. Хотя и макросы, и функции будут генерировать практически, если не просто идентичный код... в зависимости от архитектуры машины, которую вы используете для компиляции этого кода.
Итак, как решение вашей проблемы, вот как вы можете их pack и unpack:
static char pack8bit(bool* bools) {
// 'char' for an 8bit return (output) value and 'bool*' for the input 8 bools ... should be unrolled args ?!?!
char buff = 0;
for(unsigned char i = 0; i < 8; ++i)
buff = (bools[i]) ? bit_set(buff, i) : bit_clr(buff, i);
return buff;
}
static void unpack8bit(const char& from, bool* bools) {
// 'from' for the packed input and 'bool*' for the output 8 bools ... should be unrolled args ?!?!
for(unsigned char i = 0; i < 8; ++i)
bools[i] = is_bit_set(from, i) ? true : false;
}
Я знаю, что это очень поздний ответ...