Логический сдвиг вправо: Логический сдвиг — это… Что такое Логический сдвиг?

Поделиться в социальных сетях:

Битовые операторы | Кодкамп

Введение

Примеры

Побитовое И

& Оператор выполнит двоичный И, где бит копируется , если она существует в обоих операндов. Это означает:

 # 0 & 0 = 0
# 0 & 1 = 0
# 1 & 0 = 0
# 1 & 1 = 1

# 60 = 0b111100
# 30 = 0b011110
60 & 30
# Out: 28
# 28 = 0b11100

bin(60 & 30)
# Out: 0b11100 

Побитовое ИЛИ

| Оператор выполнит двоичное «или», где бит копируется, если он существует в любом из операндов. Это означает:

 # 0 | 0 = 0
# 0 | 1 = 1 
# 1 | 0 = 1
# 1 | 1 = 1

# 60 = 0b111100 
# 30 = 0b011110
60 | 30
# Out: 62
# 62 = 0b111110

bin(60 | 30)
# Out: 0b111110 

Побитовое XOR (исключающее ИЛИ)

^ Оператор будет выполнять двоичный XOR , в котором двоичный 1 копируется тогда и только тогда , когда это значение ровно один операнд. 30) # Out: 0b100010

Побитовый сдвиг влево

<< оператор выполняет побитовое «сдвиг влево» , где значение левого операнда перемещается влево на число битов данных в правом операнде.

 # 2 = 0b10
2 << 2
# Out: 8
# 8 = 0b1000

bin(2 << 2)
# Out: 0b1000

 

Выполнение левого разрядное смещение 1 эквивалентно умножению на 2 :

 7 << 1
# Out: 14

 

Выполнение левого разрядного смещения n эквивалентно умножения на 2**n :

 3 << 4
# Out: 48 

Побитовый сдвиг вправо

>> оператор выполняет побитовое «сдвиг вправо» , где значение левого операнда перемещается вправо на число битов данных в правом операнде.

 # 8 = 0b1000
8 >> 2
# Out: 2
# 2 = 0b10

bin(8 >> 2)
# Out: 0b10

 

Выполнение правильного битового смещения 1 эквивалентно целочисленного деления на 2 :

 36 >> 1
# Out: 18

15 >> 1
# Out: 7

 

Выполнение правильного битового смещения n эквивалентно целочисленное деление на 2**n :

 48 >> 4
# Out: 3

59 >> 3
# Out: 7 

Побитовое НЕ

~ Оператор переворачивает все биты числа. Поскольку компьютеры используют прямой код — прежде всего, в дополнении до двух обозначений для кодирования отрицательных двоичных чисел , где отрицательные числа записываются с ведущим один (1) вместо ведущего нуля (0).

Это означает , что если вы используете 8 бит для представления номера вашего дополнительного кода комплемента, вы бы относиться к модели от 0000 0000 до 0111 1111 для представления чисел от 0 до 127 и резервного 1xxx xxxx для представления отрицательных чисел.

Восьмиразрядные числа с двумя дополнительными числами

Биты  Значение без знака  Значение двух дополнений  0000 0000  0  0  0000 0001  1  1  0000 0010  2  2  0111 1110  126  126  0111 1111  127  127  1000 0000  128  -128  1000 0001  129  -127  1000 0010  130  -126  1111 1110  254  -2   1111 1111  255  -1

По существу, это означает , что в то время как 1010 0110 имеет беззнаковое значение 166 (прибыл в путем добавления (128 * 1) + (64 * 0) + (32 * 1) + (16 * 0) + (8 * 0) + (4 * 1) + (2 * 1) + (1 * 0) ), оно имеет значение дополнительного код дополнение -90 (прибыли в добавлении (128 * 1) - (64 * 0) - (32 * 1) - (16 * 0) - (8 * 0) - (4 * 1) - (2 * 1) - (1 * 0) , и дополняя значение).

Таким образом, отрицательные числа в диапазоне до -128 ( 1000 0000 ). Ноль (0) представляется в виде 0000 0000 , и минус один (-1) , как 1111 1111 .

В целом, однако, это означает , ~n = -n - 1 .

 # 0 = 0b0000 0000
~0
# Out: -1
# -1 = 0b1111 1111

# 1 = 0b0000 0001
~1
# Out: -2
# -2 = 1111 1110

# 2 = 0b0000 0010
~2
# Out: -3
# -3 = 0b1111 1101

# 123 = 0b0111 1011
~123
# Out: -124
# -124 = 0b1000 0100

 

Обратите внимание, что общий эффект этой операции при нанесении на положительные числа можно суммировать:

~n -> -|n+1|

И затем, применительно к отрицательным числам, соответствующий эффект:

~-n -> |n-1|

Следующие примеры иллюстрируют это последнее правило …

 # -0 = 0b0000 0000
~-0
# Out: -1 
# -1 = 0b1111 1111
# 0 is the obvious exception to this rule, as -0 == 0 always

# -1 = 0b1000 0001
~-1
# Out: 0
# 0 = 0b0000 0000

# -2 = 0b1111 1110
~-2
# Out: 1
# 1 = 0b0000 0001

# -123 = 0b1111 1011
~-123
# Out: 122
# 122 = 0b0111 1010


 

Операции на месте

Все операторы Побитового (кроме ~ ) имеет свои собственные места версии

a = 0b001
a &= 0b010 
# a = 0b000

a = 0b001
a |= 0b010 
# a = 0b011

a = 0b001
a <<= 2 
# a = 0b100

a = 0b100
a >>= 2 
# a = 0b001

a = 0b101
a ^= 0b011 
# a = 0b110

Синтаксис

Параметры

Примечания

Циклический сдвиг через бит переноса

Логический сдвиг

Сдвиг, при котором уходящий бит исчезает, не влияя на оставшиеся биты, а на месте появившегося бита записывается бит 0.

Пример работы операции сдвига:

· Пусть у нас есть число 10101010b (в двоичной системе).

· Если сделать сдвиг влево на 1 бит, то получим число 01010100b.

· Если сделать сдвиг исходного числа вправо на 1 бит, то получим число 01010101b.

В большинстве процессоров уходящий бит сохраняется во флаге переноса. Эта функция широко используется при работе со многобайтовыми числами.

Логический сдвиг влево Логический сдвиг вправо

Арифметический сдвиг

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

Арифметический сдвиг влево Арифметический сдвиг вправо

Пример №1

Пример работы операции сдвига 8 битного числа в прямом коде:

· Пусть у нас есть 8 битное число: 0000 0010b = 2. (записанное в двоичной системе, в прямом коде).

· Cдвиг влево на 1 бит, дает число: 00000100b = 4.

· Сдвиг вправо на 1 бит, дает число: 00000001b = 1.

Пример №2

Пример работы операции сдвига 8 битного числа записанного в дополнительном до 2х коде:

· Пусть у нас есть число 11111010b = −6 (в двоичной системе, в дополнительном коде).

· Если сделать сдвиг влево на 1 бит, то получим число 11110100b = −12.

· Если сделать сдвиг исходного числа вправо на 1 бит, то получим число 11111101b = −3.

Циклический сдвиг

При этом сдвиге уходящий бит появляется на месте появившегося свободного на другом конце числа.

Циклический сдвиг влево Циклический сдвиг вправо

Пример

• Пусть у нас есть число 11111010b (в двоичной системе).
• Если сделать сдвиг влево на 1 бит, то получим число 11110101b.
• Если сделать сдвиг вправо на 1 бит, то получим число 01111101b.

Циклический сдвиг через бит переноса

При нём первый бит по направлению сдвига получает значение из бита переноса, а значение последнего бита сдвигается в бит переноса.

В архитектуру многих процессоров входит флаг переноса в следующий разряд (например, cf на x86). Данная операция выполняет циклический сдвиг над (n+1)-битным числом, состоящим из регистра и флага переноса.

Флаг переноса CF (англ. Carry flag) в микропроцессорах — битовый флаг, который устанавливается, если в результате арифметической операции в (n + 1)-м значащем бите появилась единица (соответственно, в результате двоичного сдвига из разрядной сетки ушла единица).

Например, если у нас в регистре число 11111010b, флаг переноса циклического сдвига вправо равен 0.

После сдвига влево на 1 бит в регистре 11110101b, флаг переноса равен 1.

После сдвига вправо на 1 бит в регистре 01111101b, флаг переноса равен 1.

Операция циклического сдвига через бит переноса используется при работе с многобайтовыми числами. В частности, чтобы сдвинуть вправо на 1 бит длинное число, нужно очистить[1] cf (в случае деления числа со знаком нужно записать в cf старший бит старшего слова) и циклически сдвинуть на единицу через cf каждое слово, начиная с верхнего. Например, пусть у нас есть число 011000111100b, занимающее три 4-битных слова:

Было: HI=0110, MED=0011, LO=1100, cf=0

После сдвига HI: HI=0011, MED=0011, LO=1100, cf=0

После сдвига MED: HI=0011, MED=0001, LO=1100, cf=1

После сдвига LO: HI=0011, MED=0001, LO=1110, cf=0

Сдвиги через регистр флагов более чем на 1 бит практически не используются.

MSLibrary. Реализация множественного выбора условий с помощью битовых масок, для iOS и не только…

	NSRegularExpressionCaseInsensitive | NSRegularExpressionDotMatchesLineSeparators 

Один из способов реализации подобной задачи — использование списка констант в виде перечисления enum, в котором элементы перечисления представляют собой двоичные числа с одним установленным битом. Сделать это не очень сложно, но сначала немного теории. Вспомним такие битовые операции, как «СДВИГ», «И», «ИЛИ».

Побитовые логические операции с двоичными числами

ЛОГИЧЕСКИЙ БИТОВЫЙ «СДВИГ (SHIFT)»

При логическом сдвиге значение последнего бита по направлению сдвига теряется (копируясь в бит переноса), а первый приобретает нулевое значение.

Для полноты картины можно сказать, что при сдвиге влево на один разряд исходное число 01010101 превращается в 10101010. В привычной нам шестнадцатеричный системе (Hex) число 0x55 превращается в 0xAA или в десятичной системе 85 превращается в 170, то есть умножается на 2, что вполне логично.

ПОБИТОВОЕ «ИЛИ (OR)»

Это — бинарная операция, действие которой эквивалентно применению логического ИЛИ к каждой паре битов, которые стоят на одинаковых позициях в двоичных представлениях операндов. Другими словами, если оба соответствующих бита операндов равны 0, двоичный разряд результата равен 0; если же хотя бы один бит из пары равен 1, двоичный разряд результата равен 1.

Применение операции побитового «ИЛИ» к исходным числам 01100110 и 10101010 дает результат 11101110. В шестнадцатеричный системе (Hex) исходные числа 0x66 и 0xAA, результат 0xEE или в десятичной системе исходные числа 102 и 170, результат 238.

ПОБИТОВОЕ «И (AND)»

Это — бинарная операция, действие которой эквивалентно применению логического «И» к каждой паре битов, которые стоят на одинаковых позициях в двоичных представлениях операндов. Другими словами, если оба соответствующих бита операндов равны 1, результирующий двоичный разряд равен 1; если же хотя бы один бит из пары равен 0, результирующий двоичный разряд равен 0.

Применение операции побитового «И» к исходным числам 01100110 и 10101010 дает результат 00100010. В шестнадцатеричный системе (Hex) исходные числа 0x66 и 0xAA, результат 0x22 или в десятичной системе исходные числа 102 и 170, результат 34.

Двоичные числа с одним установленным битом

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

ПОРАЗРЯДНЫЙ (ПОБИТОВЫЙ) СДВИГ

Примененный к числу 00000001 поразрядный сдвиг даст следующий результат:

Операции битовых сдвигов обозначаются, в зависимости от направления сдвига, знаками «<<» и «>>»:

	двоичноеЧисло << n // битовый сдвиг влево на "n" позиций (разрядов)
	двоичноеЧисло >> n // битовый сдвиг вправо на "n" позиций (разрядов)

	1 << n	//где "n" количество позиций (разрядов) на которое осуществляется сдвиг
	1 << 0	// 00000001 сдвиг на 0 разрядов
	1 << 1 	// 00000001 сдвиг на 1 разрядов
	1 << 3 	// 00000001 сдвиг на 3 разряда
	1 << 5 	// 00000001 сдвиг на 5 разрядов

ПОБИТОВОЕ ЛОГИЧЕСКОЕ «ИЛИ (OR)»

Возьмем несколько чисел с одним установленным битом и применим к ним операцию побитового логического «ИЛИ (OR)». Записывается это так:

	1<<0 | 1<<3 | 1<<5

Замечательное свойство такой операции — в результате получается уникальное значение в данном диапазоне чисел.

Результат, полученный от применения операции побитового логического «ИЛИ» к разным числам с одним установленным битом из заданного множества чисел, всегда уникален

ПОБИТОВОЕ ЛОГИЧЕСКОЕ «И (AND)»

Второе свойство чисел с одним установленным битом — применив операцию побитового логического «И (AND)» к любому из чисел, входящих в операцию «ИЛИ (OR)» и полученному результату, мы получим исходное число:

	1 << 0 & (1 << 0 | 1 << 3 | 1 << 5) = 1 << 0
	1 << 3 & (1 << 0 | 1 << 3 | 1 << 5) = 1 << 3 
	1 << 5 & (1 << 0 | 1 << 3 | 1 << 5) = 1 << 5 

В то время, как другие числа с одним установленным битом этому условию не удовлетворяют:

	1 << 1 & (1 << 0 | 1 << 3 | 1 << 5) ≠ 1 << 1
	1 << 2 & (1 << 0 | 1 << 3 | 1 << 5) ≠ 1 << 2 
	1 << 4 & (1 << 0 | 1 << 3 | 1 << 5) ≠ 1 << 4 

Это свойство числа, полученного в результате применения операции побитового логического «ИЛИ (OR)», позволяет использовать его в качестве «БИТОВОЙ МАСКИ».

БИТОВАЯ МАСКА

Это — определённые данные, которые используются для маскирования — выбора отдельных битов или полей из нескольких битов из двоичной строки или числа.

Применив операцию побитового логического «ИЛИ (OR)» к нескольким числам с одним установленным битом, можно использовать полученный результат в качестве битовой маски для фильтрации исходных чисел из множества других.

Перечисления enum с двоичными числами с одним установленным битом

Для определения набора констант, с заданным количеством конкретных значений, удобно использовать перечисляемый тип или перечисление enum. Запишем перечисление для умозрительного примера, приведенного в начале статьи. Допустим нам надо определить пять групп пользователей. Записывается это так:

	enum Groups {
		group_0 = 0,
		group_1 = 1
		group_2 = 2,
		group_3 = 3,
		group_4 = 4,
	};

	enum Groups {
		group_0 = 1 << 0,
		group_1 = 1 << 1,
		group_2 = 1 << 2,
		group_3 = 1 << 3,
		group_4 = 1 << 4
	};

	(1 << 2 | 1 << 3) = 0x55
	1 << 2 & (1 << 2 | 1 << 3) = 1 << 2
	1 << 3 & (1 << 2 | 1 << 3) = 1 << 3
	1 << 1 & (1 << 2 | 1 << 3) ≠ 1 << 1
	1 << 4 & (1 << 2 | 1 << 3) ≠ 1 << 4

	(group_2 | group_3) = 0x55
	group_2 & (group_2 | group_3) = group_2
	group_3 & (group_2 | group_3) = group_3
	group_1 & (group_2 | group_3) ≠ group_1
	group_4 & (group_2 | group_3) ≠ group_4

Аналогично устроены многие битовые константы, в частности упоминавшиеся в начале статьи NSRegularExpressionOptions:

	typedef NS_OPTIONS(NSUInteger, NSRegularExpressionOptions) {
	NSRegularExpressionCaseInsensitive		= 1 << 0,     // Match letters in the pattern independent of case
	NSRegularExpressionAllowCommentsAndWhitespace	= 1 << 1,     // Ignore whitespace and #-prefixed comments in the pattern
	NSRegularExpressionIgnoreMetacharacters		= 1 << 2,     // Treat the entire pattern as a literal string
	NSRegularExpressionDotMatchesLineSeparators	= 1 << 3,     // Allow .  and $ to match the start and end of lines
	NSRegularExpressionUseUnixLineSeparators	= 1 << 5,     // Treat only \n as a line separator (otherwise, all standard line separators are used)
	NSRegularExpressionUseUnicodeWordBoundaries	= 1 << 6      // Use Unicode TR#29 to specify word boundaries (otherwise, traditional regular expression word boundaries are used)
}; 

	typedef NS_OPTIONS(uint64_t, NSTextCheckingType) {    // a single type
	NSTextCheckingTypeOrthography		= 1ULL << 0,            // language identification
	NSTextCheckingTypeSpelling		= 1ULL << 1,            // spell checking
	NSTextCheckingTypeGrammar		= 1ULL << 2,            // grammar checking
	NSTextCheckingTypeDate			= 1ULL << 3,            // date/time detection
	NSTextCheckingTypeAddress		= 1ULL << 4,            // address detection
	NSTextCheckingTypeLink			= 1ULL << 5,            // link detection
	NSTextCheckingTypeQuote			= 1ULL << 6,            // smart quotes
	NSTextCheckingTypeDash			= 1ULL << 7,            // smart dashes
	NSTextCheckingTypeReplacement		= 1ULL << 8,            // fixed replacements, such as copyright symbol for (c)
	NSTextCheckingTypeCorrection		= 1ULL << 9,            // autocorrection
	NSTextCheckingTypeRegularExpression	= 1ULL << 10,           // regular expression matches
	NSTextCheckingTypePhoneNumber		= 1ULL << 11,           // phone number detection
	NSTextCheckingTypeTransitInformation	= 1ULL << 12            // transit (e. g. flight) info detection
}; 

Использование оператора «if(){}»

Этот подход довольно несложен. Нижеприведенный код в особых комментариях не нуждается:

	NSInteger group_masck = (group_2 | group_3) = 0x55;
	if ((group_masck & group_0) == group_0) {
		// действие, совершаемое в случае соответствия константы и маски
	}
	if ((group_masck & group_1) == group_1) {
		// действие, совершаемое в случае соответствия константы и маски
	}
	if ((group_masck & group_2) == group_2) {
		// действие, совершаемое в случае соответствия константы и маски
	}
	if ((group_masck & group_3) == group_3) {
		// действие, совершаемое в случае соответствия константы и маски
	}
	if ((group_masck & group_4) == group_4) {
		// действие, совершаемое в случае соответствия константы и маски
	}

	NSInteger group_masck = (1 << 2 | 1 << 3) = 0x55
	if (((1 << 2 | 1 << 3) & 1 << 0) == 1 << 0) {
		// действие, совершаемое в случае соответствия константы и маски
	}
	if (((1 << 2 | 1 << 3) & 1 << 1) == 1 << 1) {
		// действие, совершаемое в случае соответствия константы и маски
	}
	if (((1 << 2 | 1 << 3) & 1 << 2) == 1 << 2) {
		// действие, совершаемое в случае соответствия константы и маски
	}
	if (((1 << 2 | 1 << 3) & 1 << 3) == 1 << 3) {
		// действие, совершаемое в случае соответствия константы и маски
	}
	if (((1 << 2 | 1 << 3) & 1 << 4) == 1 << 4) {
		// действие, совершаемое в случае соответствия константы и маски
	}

Таким образом, некие действия выполняются во всех случаях соответствия константы и маски, в нашем примере для пользователей из групп «group_2» и «group_3».

Использование операторов «for(){}» и «switch(){}»

Второй подход заключается в использовании связки операторов «for(){}» и «switch(){}». Преимущество этого варианта в том, что если для разных констант «Groups» необходимо совершать идентичные действия, например применять одни и те же функции, отличающиеся только некими переменными, то данный подход позволяет создать более компактный и изящный код:

 NSInteger group_masck = (group_2 | group_3) = 0x55;
	id variable;
	 for (int i = 0; i <= 4; i++) {
		switch (i) {
			case 0: {
				variable = value_0;
			}
				break;
			case 1: {
				variable = value_1;
			}
				break;
			case 2: {
				variable = value_2;
			}
				break;
			case 3: {
				variable = value_3;
			}
				break;
			case 4: {
				variable = value_4;
			}
				break;
			default: {
				//действие, совершаемое в случае ошибки
			}
                            break;
		}
            	if ((group_masck & 1ULL << i) == 1ULL << i) {
                		// выполняется некое действие с подстановкой переменной "variable"
            	}
	}

По такому же принципу организованы многие методы и функции нашей библиотеки MSLibrary for iOS. Для примера, функция: msfDDstringCheckingStyle() принимает значения «YES» или «NO» в зависимости от того, выполняются ли в анализируемой строке заданные условия.

 BOOL msfDDstringCheckingStyle(NSString *string, tMSstringCheckingStyle stringCheckingStyle, BOOL allConditionsIsRequired, NSInteger minLengthOfString)

Константы «stringCheckingStyle» заданы так:

 typedef enum tMSstringCheckingStyle: NSInteger {
	kMSstringCheckingStyle_digits = 1ULL << 0,			// must-have only a digits
	kMSstringCheckingStyle_englishLetters = 1ULL << 1,		// must-have only a English letters
	kMSstringCheckingStyle_russianLetters = 1ULL << 2,		// must-have only a Russian letters
	kMSstringCheckingStyle_startWithLetter = 1ULL << 3,		// the string necessarily start with a letter
	kMSstringCheckingStyle_upperAndLowerCaseLetters = 1ULL << 4,	// must-have a uppercase and a lowercase letters
	kMSstringCheckingStyle_specialSymbols = 1ULL << 5,		// must-have one or more special symbols "-" "." "+" "_"
	} tMSstringCheckingStyle;

	msfDDstringCheckingStyle(NSString *string, tMSstringCheckingStyle kMSstringCheckingStyle_digits | kMSstringCheckingStyle_englishLetters, BOOL YES, NSInteger 8)

Как видите вопрос решается всего в одну строку кода.

Другие статьи:
Захват и верификация телефонных номеров с помощью регулярных выражений, для iOS и не только… Часть 1
Захват и верификация телефонных номеров с помощью регулярных выражений, для iOS и не только… Часть 2
ПРОСТО: удаляем из строки ненужные символы, для iOS и не только…
Создание и компиляция кроссплатформенных (универсальных) библиотек в Xcode

сдвиг вправо логический

SRL используется для смены 32 бита в регистре, указанном операндом 1 справа. Количество сдвинутых битов равно обозначается операндом 2. Второй адрес операнда , а не , используемый для адресные данные; вместо этого вычисляется базовый адрес / адрес смещения и крайние правые 6 бит обрабатываются как двоичное целое число, которое представляет количество биты, которые нужно сдвинуть. Мы назовем это оцените коэффициент сдвига.Это ведет к два различных способа кодирования коэффициента сдвига:

1) Непосредственно — Коэффициент сдвига кодируется как смещение. Рассмотреть возможность пример ниже.

SRL R9,8

В указанную выше смену второй операнд, 8, рассматривается как адрес основания / смещения, где 8 — это смещение и базовый регистр опускаются. Действующий адрес — 8. (См. Explicit Обращаясь к .) При представлении в виде адреса крайние правые 6 бит по-прежнему представляют собой число 8, поэтому биты в регистр 9 сдвинут вправо на 8 бит.

2) Косвенно — Смена коэффициент помещается в регистр, и регистр упоминается как базовый Зарегистрируйтесь в базовом / замещающем адресе.

L R5, FACTOR PUT SHIFT FACTOR IN REG

SRL R9,0 (R5) ТЕПЕРЬ ПЕРЕМЕСТИТЬ КОСВЕННО

…

КОЭФФИЦИЕНТ DC F8 КОЭФФИЦИЕНТ СМЕЩЕНИЯ 8 БИТ

В этом случае эффективный адрес вычисляется путем сложения содержимого базового регистра 5 (который равен 8), со смещением 0.В эффективный адрес снова 8, и крайние правые 6 бит этого адреса указывают что коэффициент сдвига равен 8.

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

При логическом сдвиге биты, сдвинутые вправо, теряются, а 0s заменяют биты слева.

Рассмотрим следующую инструкцию.

SRL R8,6

Эта инструкция представляет сдвиг вправо регистра 8 с использованием коэффициента сдвига 6. Коэффициент сдвига был закодирован напрямую. В итоге 6 бит, 110000, сдвинуты из регистра справа. Освободившиеся битовые позиции слева заменяются нулями.Это показано на диаграмме ниже.

Эта инструкция имеет RS , но 4 младших бита второго байта не используются.

Некоторые несвязанные SRL

R5 = B111111111111111111111111111111

R6 = B11110000111100001111000011110000

SRL R5,1 R5 = B01111111111111111111111111111111

SRL R5,2 R5 = B001111111111111111111111111111

SRL R5,3 R5 = B00011111111111111111111111111111

SRL R5,31 R5 = B00000000000000000000000000000001

SRL R5,32 R5 = B00000000000000000000000000000000

SRL R6,4 R6 = B00001111000011110000111100001111

л R9, = F3

SRL R5,0 (R9) R5 = B00011111111111111111111111111111

л R3, = F5

SRL R5,0 (R3) R5 = B00000111111111111111111111111111

Логические и арифметические сдвиги — Уроки C

Одиночный бит — это основная единица памяти, в которой хранится либо 1, либо 0. Поэтому, когда биты перемещаются влево или вправо в значении определенного типа, а именно. integer, char и т. д. меняются их значения. Перемещение битов в значении на языке C выполняется с помощью операторов сдвига влево или вправо. Поскольку эти операторы работают с отдельными битами, они называются побитовыми операторами. Эти операторы работают с отдельными битами значений переменных целочисленного типа данных в их знаковой или беззнаковой форме. Символы внутренне являются целыми числами, и поэтому эти операторы работают с ними.

Оператор сдвига влево обозначается символом «>». Эти операторы являются двоичными, требуют двух операндов с каждой стороны, и оба должны быть целыми числами. Синтаксис сдвига влево и вправо следующий:

имя переменной оператор сдвига вправо / влево без битов для сдвига;

 val >> 5; / * сдвигаем значение в val вправо на 5 бит * /
    число << 5; / * сдвигаем значение в num влево на 5 бит * / 

Сдвиг называется логическим, когда выполняется с целыми числами без знака в любом направлении, вправо или влево.В логическом сдвиге при сдвиге на любую сторону пустые слоты дополняются нулями. Например:

 / *
 * rlshift.c - программа использует операторы сдвига влево и вправо с беззнаковыми
 * целые числа
 * /
#include 
int main (пусто)
{
    unsigned int b = 16, результат;

    printf ("значение exp. result = b >> 3 равно% d \ n", result = b >> 3);
    printf ("значение b после сдвига вправо на 3 бита,% d \ n", b);
    printf ("значение exp. result = b << 3 равно% d \ n", result = b << 3);
    printf ("значение b после сдвига влево на 3 бита,% d \ n", b);

    / * обратите внимание, что значение b остается неизменным после сдвига влево или вправо * /
    / * только результат изменения * /

    возврат 0;
} 

Сдвиг значения вправо на n битов приводит к делению значения на степень 2, возведенной в n, а смещение значения влево на n битов дает эффект умножения значения на степень 2, возведенную в n. Например:

 / *
 * rlshift_effect.c - программа отображает результат сдвига влево или вправо
 * значения беззнаковых целых чисел
 * /
#include 
int main (пусто)
{
    беззнаковое int b = 16;

    printf ("значение exp. b >> = 3 равно% d \ n", b >> = 3);
    printf ("значение b после сдвига вправо на 3 бита,% d \ n", b);
    printf ("значение exp. b << = 3 равно% d \ n", b << = 3);
    printf ("значение b после сдвига влево на 3 бита,% d \ n", b);

    / *
     * обратите внимание, что значение b после сдвига вправо на 3 бита равно
     * деление на 2 возводится в 3
     * и сдвиг влево на 3 бита приводит к тому, что
     * умножено на 2 и увеличено до 3
     * /

    возврат 0;
} 

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

 мальчиков >> -6;
    мальчики << -6;
    мальчики >> 35 лет; 

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

Арифметические сдвиги

До сих пор мы рассматривали сдвиг беззнаковых целых чисел вправо или влево на заданные биты и заполняли таким образом образовавшиеся пустые места нулями. Когда арифметический сдвиг вправо выполняется для отрицательного числа, то бит знака копируется в пустые слоты, созданные при сдвиге. Например:

 / * rshift_negtive_val.c - программа выполняет сдвиг вправо для -ve целых чисел * /
#include 
int main (пусто)
{
    int hall = -16;

    printf ("значение exp. hall >> = 3 равно% d \ n", hall >> = 3);
    printf ("значение холла, -ve значение, после сдвига вправо на 3 бита,"
           "is% d \ n", холл);

    / *
     * отрицательные числа сохраняются в компьютере в форме дополнения до 2
     * сдвига вправо числа -ve равно -ve, потому что знаковый бит 1 копируется
     * в пустые слоты
     * /

    возврат 0;
} 

Арифметический и логический сдвиги влево идентичны.Различаются только правые сдвиги, и то только для отрицательных значений. Следовательно, программы , которые сдвигают вправо для значений со знаком, по своей сути непереносимы.

Использование операторов смены:
Например:

 / * count_one_bit.c: Программа считает 1 бит в заданном целом числе без знака * /
#include 
void count1bits (int);

int main (пусто)
{
    int num;

    printf ("введите какое-нибудь беззнаковое целое число \ n");
    scanf ("% d", & num);

    count1bits (число); / * призыв к веселью.* /
    возврат 0;
}
void count1bits (int num1)
{
    int ones = 0;

    while (num1! = 0) {
        если (число1% 2! = 0)
            единицы ++;
        число1 >> = 1;
    }
    printf ("Количество Единиц в Значении% d \ n", единиц);
} 

Sanfoundry Global Education & Learning Series - Учебники по 1000 C.

Rotators - обзор | Темы ScienceDirect

Схема системы представлена ​​на рисунке 1.Сточные воды, поступающие с бумажной фабрики и поступающие на очистные сооружения, состоят из растворимых волокон, нерастворимых волокон, небольших кусочков пластика и песка. Блок 1 представляет собой фильтр-вращатель, в котором удаляются мелкие кусочки пластика и песок. Блок 2 представляет собой резервуар с мешалкой для гомогенизации сточных вод. В блоке 3 растворимое волокно осаждается путем добавления куагулянта (катионного биополимера) для нейтрализации электрических зарядов волокна, затем добавляется флокулянт (полиалюминийхлорид) для связывания коагулянта-волокна с другими связями.Осажденное волокно отправляется обратно на бумажный завод для повторного использования, в то время как часть осветленной воды блоком 3 направляется непосредственно на бумажный завод, а другая часть отправляется в аэробный биореактор (блок 4), где происходят реакции описать уравнением. (1) - (6) имеют место. Кислород добавляется компрессором прямого вытеснения (установка 8). Фосфат аммония добавляется, потому что концентрации азота и фосфора в биореакторе очень низкие. Блок 5, вторичный отстойник, питается выходным потоком блока 4, а остальная часть направляется в блок 7, варочный котел, для уменьшения концентрации биомассы.Затем его отправляют на окончательную утилизацию (сушильные кровати). Осветленная вода из блока 5 направляется в резервуар хлорирования (блок 6), где патогенные микроорганизмы погибают при добавлении гипохлорита натрия. Динамическая модель для биореактора этого процесса дается формулой. (1) - (7).

(1) dVbdt = Fi + Fr + Fn + Fai − Fob − Fao

(2) dSbdt = FiVb * Si + FrVb * Ss − FobVb * Sb − rs

(3) dNTbdt = FiVb * NTi + FnV * NTn + FrVb * NTs − FobVb * NTb − rNT

(4) dPO42 − bdt = FiVb * PO42 − i + FnVb * PO42 − n + FrVb * PO42 − s − FobVb * PO42 − b − rpo42−

( 5) dXbdt = FrVb * Xs − FobVb * Xb + rX

(6) dO2bdt = kLa * (O2 * −O2b) −VCO− (FobVb * O2b)

(7) dSSTbdt = FiVb * SSTi + FsrV −FobVb * SSTb

где, V _b - объем биореактора, м ³ ; t - время, сутки; F _i - входной объемный расход, м ³ · d ⁻¹ ; F _r - оборотный расход, м ³ · d ⁻¹ ; F _ob - расход на выходе, м ³ · d ^-1 ; S _b - концентрация субстрата, кг · м ⁻³ ; S _льдина - выход осветленной воды с концентрацией субстрата первичного отстойника, кг · м ⁻³ ; S _r - концентрация субстрата в рециркулируемом потоке, кг · м ⁻³ ; r _s - скорость реакции субстрата, кг · сут ^-1 ; NT _b - концентрация общего азота, кг · м ⁻³ ; NT p _floe - выход осветленной воды из первичного отстойника с концентрацией общего азота, кг · м ⁻³ ; F _n - объемный расход внешней дозировки фосфата амония, м ³ · сутки ⁻¹ ; NT _n - концентрация общего азота при внешней дозе, кг · м ⁻³ ; NT _r - концентрация общего рециркулируемого азота, кг · м ⁻³ ; r _NT - скорость реакции общего азота, кг · сут ^-1 ; PO _4b - концентрация фосфора, кг · м ⁻³ ; PO _4i - выход осветленной воды первичного отстойника с концентрацией фосфора, кг · м ⁻³ ; PO _4n - внешняя дозированная концентрация фосфора, кг · м ⁻³ ; PO _4r - концентрация рециркулируемого фосфора, кг · м ⁻³ ; r _PO4 - скорость реакции фосфора, кг · сут ^-1 ; X _b - концентрация биомассы, кг · м ⁻³ ; X _r - концентрация рециркулируемой биомассы, кг · м ⁻³ ; r _x - скорость роста биомассы, кг · сут ^-1 ; O ₂ концентрация кислорода, кг · м ⁻³ ; O ₂ * - равновесная концентрация кислорода, кг · м ⁻³ ; k _La - коэффициент массообмена, d ^-1 ; r _O2 - скорость реакции кислорода, кг · сут ⁻¹ ; SST _b - общая концентрация взвешенных веществ, кг · м ⁻³ ; SST _i - выход осветленной воды из первичного отстойника с общей концентрацией взвешенных веществ, кг · м ⁻³ ; и SST _r - общая рециклированная концентрация взвешенных твердых частиц, кг · м ^-3 .Кинетические выражения, взятые и модифицированные путем добавления зависимости от температуры и pH, были взяты из Mannina et al. (2012), и даются определяющим уравнением. (8) - (12). В таблице 1 приведены соответствующие значения и значения кинетических параметров.

Таблица 1. Числовые значения параметров

(8) rs / XKHH + rs / X / XHX * (O2bKOH + O2b + ηNO3HKOHKOH + SO2)] - [1YH * μHSbKF + SbO2bKOH + O2bPO4bKPO4 + PO4 + PO4bNTbKNh5 + NTbX * (1 + ηNO3HKNh5 + NTbX * (1 + ηNO3HBNHKOH) (9000) rNO3 9000) (9000) + iNO3 9000) (9000) μAUTO2bKOH + O2bPO4bKPO4bNTbKNh5 + NTbXAUT - [iNBM * μHSbKF + SbO2bKOH + PO4bNTbKNh5 + NTbXH * (1 + ηNO3HKOHKOH + O2B)]

(10) rPO4 = -qPPO2bKOH + O2bPO4bKPO4 + PO4bXPAO - [iPBM * μPAOO2bKOH + O2bPO4bKPO4 + PO4bNTbKNh5 + NTbXPAO * (1 + ηNO3PAO)] - iPBM * bAUTXAUT

(11) rx = [μHSbKF + SbO2bKOH + O2bPO4bKPO4b + PO4bNTbKNh5b + NTbX * 0.33 * (1 + ηNO3HKOHKOH + O2b)] - 0,33bHX + [O2bKOH + O2bPO4bKPO4 + PO4bX * 0,33 * (μPAO * NTbKNh5 + NTb * (1 + ηNO3PAO) + qPP)] - 0,33bKNObUT2Ob + μPObObObUT2BOb + μPObObObOb2 * 0,33−0,33bAUTX

(12) rO2 = [(1−1YH) ((PO4bKPO4 + PO4bNTbKNh5 + NTb) * (μHSbKF + SbO2bKOH + O2bXH + μPAOO2bKOHO + O2bXPAO2HPO + O2bXPAO)) * - - [(4.75 − YAYA) * μAUTO2bKOH + O2bPO4bKPO4 + SpoPO4b4NTbKNh5 + NTbXAUT]

Фундаментальный C - сдвигает и вращает

Страница 2 из 2

Нормализующие маски

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

 int RGBcolor = 0x010203;
int B = цвет RGB & 0x0000FF;
int G = цвет RGB & 0x00FF00;
int R = цвет RGB & 0xFF0000;
G >> = 8;
R = (без знака) R >> 16;
int data = -1;
данные << = 1; 

Теперь R равно 1, G равно 2 и B равно 3, как требуется.Обратите внимание, что мы можем сдвинуть G, не беспокоясь о знаковом бите, потому что он должен быть 0. Когда мы сдвигаем R, мы должны использовать логический сдвиг, чтобы он не интерпретировался как отрицательное значение.

Конечно, вы можете объединить операции в одно выражение:

 int RGBcolor = 0x010203;
int B = цвет RGB & 0x0000FF;
int G = (цвет RGB & 0x00FF00) >> 8;
int R = ((без знака) RGBcolor & 0xFF0000) >> 16; 

Поскольку оператор сдвига имеет более высокий приоритет, чем логическое &, скобки необходимы.

Повернуть

Существует еще одна форма сдвига - левый или правый поворот - и хотя у большинства процессоров есть инструкция, которая будет выполнять этот тип сдвига за одну операцию, по причинам истории C не имеет оператора поворота.

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

Аналогичным образом поворот влево сдвигает все биты влево и перемещает бит высокого порядка, чтобы он стал новым битом низкого порядка. Снова вы можете видеть, что это вращает биты в другом направлении. Вращения не соответствуют простому умножению или делению, и они не так полезны, как сдвиги влево и вправо для разделения битов. Они используются для криптографии и обработки сигналов.

C может не иметь оператора поворота. но легко реализовать поворот, используя поворот влево и вправо и логические операторы.

Например, поворот вправо:

 беззнаковые данные int = 0xF;
данные = данные >> 1 | данные << 31; 

Идея достаточно проста для понимания. Сначала мы выполняем логический сдвиг вправо, при котором самый старший бит обнуляется. Затем мы выполняем логический сдвиг влево 31 раз, чтобы переместить младший значащий бит в самый старший значащий бит. Они объединяются по ИЛИ, чтобы получить результат 0x80000007.

Вы можете увидеть общий принцип.Если вы хотите повернуть вправо n бит 32-битного int, используйте:

 data = data >> n | data << 32-n; 

Аналогично, если вы хотите повернуть влево n бит 32-битного значения, используйте:

 data = data << n | данные >> 32-н; 

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

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

 беззнаковые данные int = 0x0F;
данные = данные >> (без знака) 1 | данные << (без знака) 31; 

компилируется в:

 ror% eax 

, где ror - инструкция поворота вправо. Если вы оставите беззнаковые квалификаторы, строка компилируется в эквивалентные сдвиги вправо и влево, соединенные ИЛИ.

Было бы лучше, если бы в C был оператор поворота.

Проверка долота

Окончательная версия в книге

Порядок байтов

Окончательная версия в книге

Некоторые примеры.

Опции

Среднее без переполнения

Вычисление контрольной суммы

Окончательная версия в книге

Сводка

• Есть четыре побитовых логических оператора &, |, ^ и ~.Их не следует путать с логическими операторами &&, || а также !.

• Поразрядные логические операторы по-разному работают со знаковыми и беззнаковыми типами.

• Маска - это способ управления битами, на которые влияет побитовая операция.

• Есть два оператора сдвига: << арифметический или логический сдвиг влево и >> арифметический сдвиг вправо.

• Арифметический сдвиг влево соответствует умножению целочисленного типа на 2, а арифметический сдвиг вправо делит на 2.

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

• В C нет оператора поворота, но вы можете его создать.

• Маски также могут использоваться для проверки состояния бита или группы битов.

• Не существует стандарта для порядка, в котором хранятся части многобайтового значения. Little endian сначала сохраняет младшие биты, а big endian сначала хранит старшие биты.

Фундаментальный C: приближение к машине

Теперь доступен в мягкой обложке и электронной книге на Amazon.

1. О C
   Extract Dependent v Independent
   & Undefined Behavior
2. Начало работы с C с использованием NetBeans
3. Управляющие структуры и данные
4. Переменные
   Извлечь переменные
5. Арифметика и представление
   Извлечение арифметики и представления
6. Операторы и выражение
   Извлечение побочных эффектов, точек последовательности и отложенного вычисления
   Первый черновик главы: Низкие данные
7. Объем функций и срок службы
8. Массивы
   Извлечь простые массивы
   Извлечь перечисления
9. Строки
   Извлечь простые строки
10. Указатели
    Извлечь начальные указатели
    Извлечь указатели, преобразование типов и типов
11. Структуры
    Извлечь основные структуры
    Извлечь Typedef
    
12. Обработка битов
    Извлечение базовых битов *** НОВИНКА
    Извлечение сдвигает и поворачивает
    
13. Файлы
    Извлечь файлы

14. Компиляция C - препроцессор, компилятор, компоновщик
    Компиляция извлечения и препроцессор
    

См. Также сопутствующий том: Применение C

Статьи по теме

Удаленная разработка на C / C ++ с помощью NetBeans

Raspberry Pi и Интернет вещей в C

Начало работы с C / C ++ на Micro: бит

Чтобы быть в курсе новых статей на I Programmer, подпишитесь на нашу еженедельную рассылку новостей, подпишитесь на RSS-канал и подпишитесь на нас в Twitter, Facebook или Linkedin.

Комментарии

Добавление комментариев или просмотр существующих комментариев с помощью Disqus

или отправьте свой комментарий по адресу: [email protected]

; Вставить выровненную по правому краю битовую строку из регистра в
; битовая строка памяти.
;
; Предположения:
; 1) База строкового массива выровнена по двойному слову, и
; 2) длина битовой строки является непосредственным значением
; но битовое смещение хранится в регистре.;
; Регистр ESI содержит выровненную по правому краю битовую строку
; быть вставленным.
; Регистр EDI содержит битовое смещение начала
; подстрока.
; Регистры EAX и ECX также используются этим
; операция "вставка".
;
MOV ECX, EDI; сохранить исходное смещение для дальнейшего использования
SHR EDI, 3; смещение деления со знаком на 8 (адрес байта)
И CL, 7H; изолировать три младших бита смещения в CL
MOV EAX, [EDI] strg_base; переместить строковое двойное слово в EAX
ROR EAX, CL; выровнять по правому краю старое битовое поле
SHRD EAX, ESI, длина; принести новые биты
ROL EAX, длина; выравнивание по правому краю новое битовое поле
ROL EAX, CL; довести до окончательного положения
MOV [EDI] strg_base, EAX; заменить двойное слово в памяти
 

; Вставить выровненную по правому краю битовую строку из регистра в
; битовая строка памяти.
;
; Предположения:
; 1) База строкового массива выровнена по двойному слову, и
; 2) длина битовой строки является непосредственным значением
; но битовое смещение хранится в регистре.
;
; Регистр ESI содержит выровненную по правому краю битовую строку
; быть вставленным.
; Регистр EDI содержит битовое смещение начала
; подстрока.
; Регистры EAX, EBX, ECX и EDI также используются
; эта операция "вставки".;
MOV ECX, EDI; временное хранилище для смещения
SHR EDI, 5; смещение деления со знаком на 32 (адрес двойного слова)
SHL EDI, 2; умножить на 4 (в формате байтового адреса)
И CL, 1FH; изолировать младшие пять бит смещения в CL
MOV EAX, [EDI] strg_base; переместить двойное слово с низкой строкой в ​​EAX
MOV EDX, [EDI] strg_base + 4; другое строковое слово в EDX
MOV EBX, EAX; временное хранилище для части строки + поворот
SHRD EAX, EDX, CL; двойной сдвиг по смещению внутри dword + EDX: EAX
SHRD EAX, EBX, CL; двойной сдвиг по смещению в пределах двойного слова + вправо
SHRD EAX, ESI, длина; принести новые биты
ROL EAX, длина; выравнивание по правому краю новое битовое поле
MOV EBX, EAX; временное хранилище для части строки + поворот
SHLD EAX, EDX, CL; двойной сдвиг назад по смещению внутри слова + EDX: EAX
SHLD EDX, EBX, CL; двойной сдвиг назад по смещению внутри слова + влево
MOV [EDI] strg_base, EAX; заменить двойное слово в памяти
MOV [EDI] strg_base + 4, EDX; заменить двойное слово в памяти
 

; Вставить выровненную по правому краю битовую строку из регистра в
; битовая строка памяти.
;
; Предположения:
; 1) База строкового массива выровнена по двойному слову, и
; 2) длина битовой строки 32
; но битовое смещение хранится в регистре.
;
; Регистр ESI содержит 32-битную строку, которую нужно вставить.
; Регистр EDI содержит битовое смещение начала
; подстрока.
; Регистры EAX, EBX, ECX и EDI также используются
; эта операция "вставки".
;
MOV EDX, EDI; сохранить исходное смещение для дальнейшего использования
SHR EDI, 5; смещение деления со знаком на 32 (адрес двойного слова)
SHL EDI, 2; умножить на 4 (в формате байтового адреса)
И CL, 1FH; изолировать младшие пять бит смещения в CL
MOV EAX, [EDI] strg_base; переместить двойное слово с низкой строкой в ​​EAX
MOV EDX, [EDI] strg_base + 4; другое строковое слово в EDX
MOV EBX, EAX; временное хранилище для части строки + поворот
SHRD EAX, EDX; двойной сдвиг по смещению внутри dword + EDX: EAX
SHRD EDX, EBX; двойной сдвиг по смещению в пределах двойного слова + вправо
MOV EAX, ESI; переместить 32-битное поле на место
MOV EBX, EAX; временное хранилище для части строки + поворот
SHLD EAX, EDX; двойной сдвиг назад по смещению внутри слова + EDX: EAX
SHLD EDX, EBX; двойной сдвиг назад по смещению внутри слова + влево
MOV [EDI] strg_base, EAX; заменить двойное слово в памяти
MOV [EDI] strg_base, + 4, EDX; заменить двойное слово в памяти
 

; Извлечь выровненную по правому краю битовую строку из бита памяти
; строка в регистр
;
; Предположения:
; 1) База строкового массива выровнена по двойному слову, и
; 2) длина битовой строки является непосредственным значением
; но битовое смещение хранится в регистре.
;
; Регистр EAX содержит выровненные по правому краю и дополненные нулями
; битовая строка, которая была извлечена.
; Регистр EDI содержит битовое смещение начала
; подстрока.
; Регистры EDI и ECX также используются этой «выдержкой»."
;
MOV ECX, EDI; временное хранилище для смещения
SHR EDI, 3; смещение деления со знаком на 8 (адрес байта)
И CL, 7H; изолировать три младших бита смещения
MOV EAX, [EDI] strg_base; переместить строковое двойное слово в EAX
SHR EAX, CL; сдвиг по смещению в пределах двойного слова
AND EAX, маска; извлеченное битовое поле в EAX
 

; Извлечь выровненную по правому краю битовую строку из бита памяти
; строка в регистр.;
; Предположения:
; 1) База строкового массива выровнена по двойному слову, и
; 2) длина битовой строки является непосредственной
; значение, но битовое смещение хранится в регистре.
;
; Регистр EAX содержит выровненные по правому краю и дополненные нулями
; битовая строка, которая была извлечена.
; Регистр EDI содержит битовое смещение начала
; подстрока.
; Регистры EAX, EBX и ECX также используются этим «извлечением».
MOV ECX, EDI; временное хранилище для смещения
SHR EDI, 5; смещение деления со знаком на 32 (адрес двойного слова)
SHL EDI, 2; умножить на 4 (в формате байтового адреса)
И CL, 1FH; изолировать младшие пять бит смещения в CL
MOV EAX, [EDI] strg_base; переместить двойное слово с низкой строкой в ​​EAX
MOV EDX, [EDI] strg_base + 4; другое строковое слово в EDX
SHRD EAX, EDX, CL; двойной сдвиг вправо по смещению внутри двойного слова
AND EAX, маска; извлеченное битовое поле в EAX
 

 ПЕЧАТЬ ~ & 87654321 >>> 4
 

 Операнд 10000111011001010100001100100001
            \
1-я смена 01000011101100101010000110010000 â † ’
             \
2-я смена 00100001110110010101000011001000 â † ’
              \
3-я смена 00010000111011001010100001100100 â † ’
               \
4-я смена 00001000011101100101010000110010 â † ’
 

> ПЕЧАТЬ ~ & 87654321 >>> 4
   8765432
 

 ЕСЛИ (двойное слово% >>> 24) = 1 ТО...