Как вы используете побитовые флаги в C ++?

Если Вы хотите использовать битовые поля затем, это - простой способ:

typedef struct MAZENODE
{
    bool backtrack_north:1;
    bool backtrack_south:1;
    bool backtrack_east:1;
    bool backtrack_west:1;
    bool solution_north:1;
    bool solution_south:1;
    bool solution_east:1;
    bool solution_west:1;
    bool maze_north:1;
    bool maze_south:1;
    bool maze_east:1;
    bool maze_west:1;
    bool walls_north:1;
    bool walls_south:1;
    bool walls_east:1;
    bool walls_west:1;
};

Затем Ваш код может просто протестировать каждого на TRUE или FALSE.

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

Иначе используйте битовые поля C++ (но знайте, что упорядочивание битов в целом числе будет зависимо от компилятора).

Для управления наборами битов можно также использовать....

std::bitset<N>

std::bitset<4*4> bits;
bits[ 10 ] = false;
bits.set(10);
bits.flip();
assert( !bits.test(10) );

Изучите свой поразрядный opertors: и, |, ^, и!.

Наверху большого количества файлов C/C++ я видел флаги, определенные в шестнадцатеричном числе для маскирования каждого бита.

#define ONE 0x0001

Видеть, включено ли немного, Вы И это с 1. Включать его, Вы ИЛИ он с 1. Переключаться как переключатель, XOR это с 1.

Можно сделать это с шестнадцатеричными флагами или перечислениями, как Вы предположили, но самое читаемое / самодокументирование должны, вероятно, использовать то, что называют "битовыми полями" (для получения дополнительной информации Google для C++ bitfields).

Да хороший путь состоит в том, чтобы использовать шестнадцатеричное десятичное число для представления комбинаций двоичных разрядов. Затем Вы используете побитовые операторы для управления 16-разрядным ints.

Например:

if(x & 0x01){} // tests if bit 0 is set using bitwise AND
x ^= 0x02;     // toggles bit 1 (0 based) using bitwise XOR
x |= 0x10;     // sets bit 4 (0 based) using bitwise OR

Я не большой поклонник битсета. На мой взгляд, это просто больше печатать. И все равно это не скрывает того, что вы делаете. Вам все еще нужно & && | биты. Если вы не придираетесь только к 1 биту. Это может сработать для небольших групп флагов. Не то чтобы нам тоже нужно скрывать то, что мы делаем. Но цель класса обычно состоит в том, чтобы облегчить пользователям задачу. Я не думаю, что этот класс выполняет это.

Допустим, у вас есть система флагов с .. 64 флагами. Если вы хотите протестировать ... Я не знаю ... 39 из них в 1 операторе if, чтобы увидеть, все ли они включены ... использование битовых полей - огромная боль. Вы должны их все напечатать .. Конечно. Я предполагаю, что вы используете только функции битовых полей, а не методы смешивания и сопоставления. То же самое и с битсетом. Если я не упускаю что-то в классе ... что вполне возможно, так как я редко использую его ... Я не вижу способа, которым вы можете проверить все 39 флагов, если вы не наберете дырку или не прибегнете к "стандартным методам" (используя списки флагов перечисления или какое-то определенное значение для 39 бит и с использованием набора битов && оператора). Это может начать запутываться в зависимости от вашего подхода. И я знаю ... 64 флага - это много. И хорошо. Это .. в зависимости от того, что вы делаете. Лично говоря, большинство проектов, в которых я участвую, зависят от систем флагов. Так что на самом деле .. 64 - это не что-то неслыханное. Хотя, по моему опыту, 16 ~ 32 гораздо более распространены. Я на самом деле сейчас помогаю в проекте, где одна система флагов имеет 640 бит. По сути, это система привилегий. Так что есть смысл расположить их все вместе ... Однако .. правда ..