Как передать заключенный в кавычки символ вертикальной черты cmd.exe?

Скажем, у нас есть единственный байт:

0110110

Применение единственного левого сдвига разряда получает нас:

1101100

крайний левый нуль был смещен из байта, и новый нуль был добавлен к правильному концу байта.

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

Смещение, оставленное N, эквивалентно умножению на 2 N глоток>.

Смещающееся право N (если Вы используете дополнение ), эквивалент деления на 2 N глоток> и округление для обнуления.

Bitshifting может использоваться для безумно быстрого умножения и разделения, если Вы работаете с питанием 2. Почти все стандартные программы низкокачественной графики используют bitshifting.

, Например, путь назад в былые дни, мы использовали 13-й режим (320x200 256 цветов) для игр. В 13-м Режиме видеопамять была размечена последовательно на пиксель. Это означало вычислять местоположение для пикселя, Вы будете использовать следующую математику:

memoryOffset = (row * 320) + column

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

Однако 320 не питание два, так для обхождения этого мы должны узнать то, что является питанием два, который добавил, вместе делает 320:

(row * 320) = (row * 256) + (row * 64)

Теперь мы можем преобразовать это в сдвиги влево:

(row * 320) = (row << 8) + (row << 6)

Для конечного результата:

memoryOffset = ((row << 8) + (row << 6)) + column

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

mov ax, 320; 2 cycles
mul word [row]; 22 CPU Cycles
mov di,ax; 2 cycles
add di, [column]; 2 cycles
; di = [row]*320 + [column]

; 16-bit addressing mode limitations:
; [di] is a valid addressing mode, but [ax] isn't, otherwise we could skip the last mov

Общее количество: 28 циклов на любом древнем ЦП имели эти синхронизации.

циклы Vrs

mov ax, [row]; 2 cycles
mov di, ax; 2
shl ax, 6;  2
shl di, 8;  2
add di, ax; 2    (320 = 256+64)
add di, [column]; 2
; di = [row]*(256+64) + [column]

12 на том же древнем ЦП.

Да, мы работали бы это трудно для бритья 16 циклов ЦП.

В 32 или 64-разрядный режим, обе версии становятся намного короче и быстрее. Современные центральные процессоры выполнения с изменением последовательности как Intel Skylake (см. http://agner.org/optimize/ ) имеют очень быстрые аппаратные средства, умножаются (низкая задержка и высокая пропускная способность), таким образом, усиление намного меньше. Семья бульдозера AMD немного медленнее, специально для 64-разрядного умножаются. На Intel CPUs и AMD Ryzen, два сдвига являются немного более низкой задержкой, но больше инструкций, чем умножение (который может вести для понижения пропускной способности):

imul edi, [row], 320    ; 3 cycle latency from [row] being ready
add  edi, [column]      ; 1 cycle latency (from [column] and edi being ready).
; edi = [row]*(256+64) + [column],  in 4 cycles from [row] being ready.

по сравнению с [1 137]

mov edi, [row]
shl edi, 6               ; row*64.   1 cycle latency
lea edi, [edi + edi*4]   ; row*(64 + 64*4).  1 cycle latency
add edi, [column]        ; 1 cycle latency from edi and [column] both being ready
; edi = [row]*(256+64) + [column],  in 3 cycles from [row] being ready.

Компиляторы сделают это для Вас: Посмотрите как gcc, лязг и MSVC все использование shift+lea при оптимизации return 320*row + col; .

самая интересная вещь отметить вот состоит в том, что x86 имеет инструкцию shift-and-add (LEA) , который может сделать маленькие сдвиги влево и добавить одновременно с представлением в качестве и add инструкция. ARM еще более мощен: один операнд любой инструкции может быть лев или прав смещенный бесплатно. Так масштабируясь постоянным во времени компиляцией это, как известно, является power-2, может быть еще более эффективным, чем умножение.

хорошо, назад в современные дни... что-то более полезное теперь должно было бы использовать bitshifting для хранения двух 8-разрядных значений в 16-разрядном целом числе. Например, в C#:

// Byte1: 11110000
// Byte2: 00001111

Int16 value = ((byte)(Byte1 >> 8) | Byte2));

// value = 000011111110000;

В C++, компиляторы должны сделать это для Вас, если бы Вы использовали struct с двумя 8-разрядными участниками, но на практике сделайте не всегда.