Что означают две левые угловые скобки в C #?

Это будет оператор побитового сдвига влево.

Для каждого сдвига влево значение эффективно умножается на 2. Так, например, запись value << 3 умножит значение на 8.

На самом деле он перемещает все фактические биты значения на одно место. Итак, если у вас есть значение 12 (десятичное), в двоичном формате это 00001100; сдвиг влево на одно место превратит это в 00011000, или 24.

Когда ты пишешь

1 << n

Вы сдвигаете битовую комбинацию 000000001 на n раз влево и, таким образом, помещаете n в показатель степени 2:

2^n

So

1 << 10

На самом деле

1024

Для списка из 5 элементов ваш for будет повторяться 32 раза.

Он называется оператором left-shift. Ознакомьтесь с документацией

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

Простой пример, демонстрирующий оператор left-shift:

for (int i = 0; i < 10; i++)
{
    var shiftedValue = 1 << i;
    Console.WriteLine(" 1 << {0} = {1} \t Binary: {2}",i,shiftedValue,Convert.ToString(shiftedValue,2).PadLeft(10,'0'));
}

//Output:

// 1 << 0 = 1      Binary: 0000000001
// 1 << 1 = 2      Binary: 0000000010
// 1 << 2 = 4      Binary: 0000000100
// 1 << 3 = 8      Binary: 0000001000
// 1 << 4 = 16     Binary: 0000010000
// 1 << 5 = 32     Binary: 0000100000
// 1 << 6 = 64     Binary: 0001000000
// 1 << 7 = 128    Binary: 0010000000
// 1 << 8 = 256    Binary: 0100000000
// 1 << 9 = 512    Binary: 1000000000

Перемещение одного бита влево эквивалентно умножению на два. Фактически, перемещение битов происходит быстрее, чем стандартное умножение. Давайте посмотрим на пример, демонстрирующий этот факт:

Допустим, у нас есть два метода:

static void ShiftBits(long number,int count)
{
    long value = number;
    for (int i = 0; i < count; i+=128)
    {
          for (int j = 1; j < 65; j++)
          {
              value = value << j;
          }
          for (int j = 1; j < 65; j++)
          {
               value = value >> j;
          }
    }
}

static void MultipleAndDivide(long number, int count)
{
      long value = number;
      for (int i = 0; i < count; i += 128)
      {
            for (int j = 1; j < 65; j++)
            {
                value = value * (2 * j);
            }
            for (int j = 1; j < 65; j++)
            {
                value = value / (2 * j);
            }
      }
}

И мы хотим протестировать их так:

ShiftBits(1, 10000000);
ShiftBits(1, 100000000);
ShiftBits(1, 1000000000);
...
MultipleAndDivide(1, 10000000);
MultipleAndDivide(1, 100000000);
MultipleAndDivide(1, 1000000000);
...

Вот результаты:

Bit manipulation 10.000.000 times: 58 milliseconds
Bit manipulation 100.000.000 times: 375 milliseconds
Bit manipulation 1.000.000.000 times: 4073 milliseconds

Multiplication and Division 10.000.000 times: 81 milliseconds
Multiplication and Division 100.000.000 times: 824 milliseconds
Multiplication and Division 1.000.000.000 times: 8224 milliseconds

Это Побитовый сдвиг влево он работает, сдвигая цифры двоичного эквивалента числа на заданные (правые) числа.

so:

temp = 14 << 2

двоичный эквивалент 14 00001110 сдвиг его 2 раза означает нажатие нуля с правой стороны и сдвиг каждой цифры влево, что делает 00111000 равным 56.

В вашем примере:

i < (1 << list.Count)

• 0000000001 = 1, если list.Count = 0 результат равен 0000000001 = 1
• 0000000001 = 1, если list.Count = 1 результат равен 0000000010 = 2
• 0000000001 = 1, если list.Count = 2 результат равен 0000000100 = 4
• 0000000001 = 1, если list.Count = 3 результат равен 0000001000 = 8

и так далее. Обычно он равен 2 ^ list.Count (2 в степени list.Count)

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

Get = 1 << 0, // 1
Post = 1 << 1, // 2
Put = 1 << 2,  // 4
Delete = 1 << 3, // 8
Head = 1 << 4  // 16

Это семантически эквивалентно lOperand * Math.Pow(2, rOperand)

Целью цикла, скорее всего, является создание или работа со всеми подмножествами набора элементов в списке. И тело цикла, скорее всего, также имеет хороший бит (хар-хар) побитовых операций, а именно как еще один сдвиг влево и побитовое и. (Так что переписывать его для использования Pow было бы очень глупо, я не могу поверить, что было так много людей, которые на самом деле предлагали это.)

Это немного сдвигается. В основном это просто перемещение битов влево, добавляя 0 к правой стороне.

public enum HttpVerbs {
    Get = 1 << 0,    // 00000001 -> 00000001 = 1
    Post = 1 << 1,   // 00000001 -> 00000010 = 2
    Put = 1 << 2,    // 00000001 -> 00000100 = 4
    Delete = 1 << 3, // 00000001 -> 00001000 = 8
    Head = 1 << 4    // 00000001 -> 00010000 = 16
}

Дополнительная информация на http://www.blackwasp.co.uk/CSharpShiftOperators.aspx

В дополнение к ответу Selman22 несколько примеров:

Я перечислю несколько значений для list.Count и того, каким будет цикл:

list.Count == 0: for (int i = 0; i < 1; i++)
list.Count == 1: for (int i = 0; i < 2; i++)
list.Count == 2: for (int i = 0; i < 4; i++)
list.Count == 3: for (int i = 0; i < 8; i++)

И так далее.

«Битовый сдвиг влево». 1 << 0 означает «взять целочисленное значение 1 и сдвинуть его биты влево на нулевые биты». То есть 00000001 остается без изменений. 1 << 1 означает «взять целочисленное значение 1 и сдвинуть его биты влево на одно место». 00000001 становится 00000010.

Его (‹<) оператор побитового сдвига влево, он перемещает битовые значения двоичного объекта. Левый операнд определяет значение, которое должно быть сдвинуто, а правый операнд определяет количество позиций, на которые должны быть сдвинуты биты в значении.

В вашем случае, если значение list.count равно 4, цикл будет выполняться до i ‹(1 ‹---------------- 4), который равен 16 (00010000)

00000001 << 4 = 00010000(16)

Это подразумевается во многих ответах, но никогда не говорится прямо ...

Для каждой позиции, на которую вы сдвигаете двоичное число влево, вы удваиваете исходное значение числа.

Например,

Десятичное число 5, сдвинутое влево на единицу, равно десятичному числу 10 или десятичному числу 5, удвоенному.

Десятичное число 5, сдвинутое влево на 3, является десятичным числом 40 или десятичным числом 5, удвоенным 3 раза.

Выражение (1 << N) использует битовый сдвиг в C #.

В этом случае он используется для быстрого целочисленного вычисления 2 ^ N, где n от 0 до 30.

Хорошим инструментом для молодых разработчиков, которые не понимают, как работают битовые сдвиги, является Windows Calc в режиме программиста, который визуализирует влияние сдвигов на подписанные числа различного размера. Функции Lsh и Rsh приравниваются к << и >> соответственно.

Оценка с использованием Math.Pow внутри условия цикла (в моей системе) примерно в 7 раз медленнее, чем код вопроса для N = 10, зависит ли это от контекста.

Кэширование «счетчика циклов» в отдельной переменной немного ускорит его, так как выражение, включающее длину списка, не нужно будет повторно вычислять на каждой итерации.

В предыдущих ответах объяснялось, что, но, похоже, никто не догадался, почему. Мне кажется весьма вероятным, что причина этого кода в том, что цикл повторяется по каждой возможной комбинации членов списка - это единственная причина, по которой я могу понять, почему вы захотите повторить итерацию до 2 ^ {list. Считать}. Следовательно, переменная i была бы неправильно названа: вместо индекса (что я обычно интерпретирую как значение 'i') ее биты представляют собой комбинацию элементов из списка, поэтому (например) первый элемент может быть выбран, если нулевой бит i установлен ((i & (1 << 0)) != 0), второй элемент, если установлен бит один ((i & (1 << 1)) != 0) и так далее. 1 << list.Count, следовательно, является первым целым числом, которое не соответствует допустимой комбинации элементов из списка, так как оно указывает на выбор несуществующего list[list.Count].

Я знаю, что этот ответ в значительной степени решен, но я подумал, что визуализация может кому-то помочь.

[Fact] public void Bit_shift_left()
{
    Assert.Equal(Convert.ToInt32("0001", 2), 1 << 0); // 1
    Assert.Equal(Convert.ToInt32("0010", 2), 1 << 1); // 2
    Assert.Equal(Convert.ToInt32("0100", 2), 1 << 2); // 4
    Assert.Equal(Convert.ToInt32("1000", 2), 1 << 3); // 8
}

<< - оператор сдвига левого бита. Если у вас есть число 3, которое равно 00000011 в двоичном формате, вы можете написать 3 << 2, что равно 00001100, или 12 в десятичном формате.