Зачем кому-то использовать оператор << в объявлении перечисления?

Ответ 1

Это позволяет вам сделать что-то вроде этого:

var myEnumValue = MyEnum.open | MyEnum.close;

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

(например, это):

public enum MyEnum
{
    open     = 1,
    close    = 2,
    Maybe    = 4,
    ........
}

Ответ 2

Обычно это используется с битовыми полями, так как он ясно показывает, что такое шаблон, устраняет необходимость вручную вычислять правильные значения и, следовательно, уменьшает вероятность ошибок

[Flags]
public enum SomeBitField
{
    open = 1 << 0    //1
    closed = 1 << 1  //2
    maybe = 1 << 2   //4
    other = 1 << 3   //8
    ...
}

Ответ 3

Чтобы избежать ввода значений для перечисления Flags вручную.

public enum MyEnum
{
    open     = 0x01,
    close    = 0x02,
    Maybe    = 0x04,
    ........
}

Ответ 4

Он просто предназначен для более чистого/интуитивного способа записи бит. 1, 2, 3 - более понятная для человека последовательность, чем 0x1, 0x2, 0x4 и т.д.

Ответ 5

Это сделать перечисление, которое вы можете комбинировать.

То, что это эффективно означает, это:

public enum MyEnum
{
    open = 1;
    close = 2;
    Maybe = 4;
    //...
}

Это просто более пуленепробиваемый метод создания перечисления [Flags].

Ответ 6

Здесь много ответов, описывающих, что этот механик позволяет вам делать, но не почему вы хотели бы использовать его. Вот почему.

Краткая версия:

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

Итак, я мог позвонить вам по телефону и сказать: "Эй, какой бит для открытия файл? "И вы скажете" Бит 0 ". И я напишу в своем коде open = 1 << 0. Поскольку число справа от << указывает номер бит.

.

Длинная версия:

Традиционно биты в слове нумеруются справа налево, начиная с нуля. Таким образом, младший бит бит бит 0, и вы рассчитываете, когда идете в сторону самый значительный бит. Есть несколько преимуществ для маркировки битов путь.

Одно из преимуществ заключается в том, что вы можете говорить о одном и том же бите, независимо от размера слова. Например, я мог бы сказать, что как в 32-битном слове 0x384A, так и в 8-битовом слове 0x63 бит 6 и 1. Если вы пронумеровали свои биты в другом направлении, вы не смогли бы сделайте это.

Еще одно преимущество заключается в том, что битовое значение просто увеличивается до мощности бит должность. Например, двоичный 0101 имеет биты 2 и 0. Бит 2 способствует значение 4 (2^2) к числу, а бит 0 вносит значение 1 (2 ^ 0). Итак числовое значение, конечно, 4 + 1 = 5.

Это длинное объяснение фона приводит нас к сути: нотация << сообщает вам номер бит, просто взглянув на него.

Число 1 само по себе в утверждении 1 << n - это просто бит, установленный в бит 0. Когда вы сдвигаете это число слева, вы затем перемещаете этот набор бит в другую позицию в номере. Удобно, количество, которое вы сдвигаете сообщает номер бит, который будет установлен.

1 << 5:   This means bit 5.   The value is 0x20.
1 << 12:  This means bit 12.  The value is 0x40000.
1 << 17:  This means bit 17.  The value is 0x1000000.
1 << 54:  This means bit 54.  The value is 0x40000000000000.
          (You can probably see that this notation might be helpful if
          you're defining bits in a 64-bit number)

Эта нотация действительно пригодится, когда вы взаимодействуете с другим компонент, например, сопоставление бит в слове с аппаратным регистром. Как вы могли бы есть устройство, которое включается, когда вы пишете бит 7. Таким образом, инженер-аппаратчик напишет лист данных, в котором говорится, что бит 7 позволяет устройству. И вы должны писать в ваш код ENABLE = 1 << 7. Легко, как это.

О, стреляй. Инженер просто отправил исправления в техническое описание, в котором говорилось, что это должен быть бит 15, а не бит 7. Это нормально, просто измените код на ENABLE = 1 << 15.

Что делать, если ENABLE было фактически, когда оба бита 7 и 1 были установлены одновременно?

ENABLE = (1 << 7) | (1 << 1).

Сначала это может показаться странным и тупым, но вы привыкнете к нему. И ты будешь оцените это, если вам когда-либо явно нужно знать номер бит.

Ответ 7

Он равен степеням двух.

public enum SomeEnum
{
    Enum1 = 1 << 0,    //1
    Enum2 = 1 << 1,    //2
    Enum3 = 1 << 2,    //4
    Enum4 = 1 << 3     //8
}

И с таким перечислением у вас будет функция, которая выглядит так:

void foo(unsigned ind flags)
{
    for (int = 0; i < MAX_NUMS; i++)
        if (1 << i & flags)
        {
            //do some stuff...
            //parameter to that stuff probably is i either enum value
        }
}

И вызов этой функции будет foo(Enum2 | Enum3);, и он сделает что-то со всеми указанными значениями перечисления.