O.2 -- Operatory bitowe

Operatory bitowe

C++ udostępnia często 6-bitowe operatory manipulacji wywoływane operatory bitowe operatory:

Są to operatory niemodyfikujące (nie modyfikują swoich argumentów).

Operatory bitowe są zdefiniowane dla całki typy i std::bitsetBędziemy używać std::bitset w naszych przykładach, ponieważ łatwiej jest wydrukować dane wyjściowe w formacie binarnym.

Unikaj używania operatorów bitowych z argumentami całkowitymi ze znakiem, ponieważ wiele operatorów zwróci wyniki zdefiniowane w implementacji przed C++20 lub będzie miało inne potencjalne problemy, których można łatwo uniknąć używając operandów bez znaku (lub std::bitset).

Operandy bitowego przesunięcia w lewo (<<) i bitowe przesunięcia w prawo (>>)

Klasa bitowe przesunięcie w lewo (<<) Operator przesuwa bity w lewo Lewy operand jest wyrażeniem zapewniającym początkową sekwencję bitów, a prawy operand jest liczbą całkowitą określającą liczbę pozycji bitowych, o które należy przesunąć bity. Na przykład, gdy piszemy x << 2, mówimy „tworzą wartość, w której bity z x zostały przesunięte o 2 pozycje w lewo.”

Lewy operand nie jest modyfikowany, a nowe bity przesunięte z prawidłowego rozmiaru to 0.

Oto kilka przykładów przesunięcia sekwencji bitów w lewo 0011:

0011 \<\< 1 is 0110
0011 \<\< 2 is 1100
0011 \<\< 3 is 1000

Zauważ, że w trzecim przypadku przesunęliśmy 1 bit na końcu liczby! Bity przesunięte poza koniec sekwencji bitów zostają utracone na zawsze.

Klasa operator bitowego przesunięcia w prawo (>>) działa podobnie, ale przesuwa bity w prawo.

Oto kilka przykładów przesunięcia sekwencji bitów w prawo 1100:

1100 />/> 1 is 0110
1100 />/> 2 is 0011
1100 />/> 3 is 0001

Zauważ, że w trzecim przypadku przesunęliśmy się nieco w prawo koniec liczby, więc zostaje ona utracona.

Zróbmy przykład w C++, który można skompilować i uruchomić:

#include <bitset>
#include <iostream>

int main()
{
    std::bitset<4> x { 0b1100 };

    std::cout << x << '\n';
    std::cout << (x >> 1) << '\n'; // shift right by 1, yielding 0110
    std::cout << (x << 1) << '\n'; // shift left by 1, yielding 1000

    return 0;
}

Wypisuje:

1100
0110
1000

Co!? Czy operator<< i operator>> nie są używane do wprowadzania i wyprowadzania danych?

Na pewno tak.

Współczesne programy zazwyczaj nie wykorzystują zbytnio operatorów przesunięcia bitowego w lewo i w prawo do przesuwania bitów. Zamiast tego operator przesunięcia bitowego w lewo jest częściej używany z std::cout (lub innymi obiektami strumienia wyjściowego) do wyświetlania tekstu. Rozważmy następujący program:

#include <bitset>
#include <iostream>

int main()
{
    unsigned int x { 0b0100 };
    x = x << 1; // use operator<< for left shift
    std::cout << std::bitset<4>{ x } << '\n'; // use operator<< for output

    return 0;
}

Ten program wypisuje:

1000

W powyższym programie czy operator<< wie, jak przesuwać bity w jednym przypadku i wyprowadzać x w innym? Odpowiedź jest taka, że sprawdza typ operandów. Jeśli lewy operand jest typem całkowitym, to operator<< wie, jak to zrobić w typowy sposób przesuwania bitów, jeśli lewy operand jest obiektem strumienia wyjściowego, jak std::cout, to wie, że zamiast tego powinien wysyłać dane wyjściowe.

To samo dotyczy operator>>.

Pamiętaj, że jeśli używasz operator<< zarówno do wyjścia, jak i lewego przesunięcia, w przypadku przesunięcia w lewo wymagane jest użycie nawiasów:

#include <bitset>
#include <iostream>

int main()
{
	std::bitset<4> x{ 0b0110 };

	std::cout << x << 1 << '\n'; // print value of x (0110), then 1
	std::cout << (x << 1) << '\n'; // print x left shifted by 1 (1100)

	return 0;
}

Wypisuje:

01101
1100

Pierwsza linia wypisuje wartość x (0110), a następnie literał 1. Druga linia wypisuje wartość x przesuniętą w lewo przez 1 (1100).

Bitowo NOT

Klasa bitowego NOT operator (~) jest koncepcyjnie prosta: po prostu odwraca każdy bit z 0 do 1 lub odwrotnie.

~0011 is 1100
~0000 0100 is 1111 1011

#include <bitset>
#include <iostream>

int main()
{
    std::bitset<4> b4{ 0b100 }; // b4 is 0100
    std::bitset<8> b8{ 0b100 }; // b8 is 0000 0100

    std::cout << "Initial values:\n";
    std::cout << "Bits: " << b4 << ' ' << b8 << '\n';
    std::cout << "Values: " << b4.to_ulong() << ' ' << b8.to_ulong() << "\n\n";    

    b4 = ~b4; // flip b4 to 1011
    b8 = ~b8; // flip b8 to 1111 1011
    
    std::cout << "After bitwise NOT:\n";
    std::cout << "Bits: " << b4 << ' ' << b8 << '\n';
    std::cout << "Values: " << b4.to_ulong() << ' ' << b8.to_ulong() << '\n';    

    return 0;
}

Initial values:
Bits: 0100 00000100
Values: 4 4

After bitwise NOT:
Bits: 1011 11111011
Values: 11 251

Bitowo LUB

Bitowo LUB (|) działa podobnie jak jego logiczny odpowiednik OR. Jeśli pamiętasz, logiczne OR ma wartość true (1), jeśli którykolwiek z operandów są true, w przeciwnym razie ma wartość false (0).

Jednakże, podczas gdy logiczne OR jest stosowane do całego operandu (w celu uzyskania pojedynczego wyniku prawdziwego lub fałszywego), bitowe OR jest stosowane do każdej pary bitów w operandach (w celu uzyskania pojedynczego prawdziwego lub fałszywego wyniku dla każdego bit).

Zilustrujmy to przykładem. Rozważmy wyrażenie 0b0101 | 0b0110.

0 1 0 1 OR (or whatever bitwise operation you are doing)
0 1 1 0

W pierwszej kolumna, 0 LUB 0 Jest 0, więc pod linią wstawiamy 0.

0 1 0 1 OR
0 1 1 0
-------
0

Druga kolumna, 1 LUB 1 Jest 1. Trzecia kolumna 0 lub 1 Jest 1. I czwarta kolumna, 1 lub 0 Jest 1.

0 1 0 1 OR
0 1 1 0
-------
0 1 1 1

Nasz wynik jest 0111 binarny.

#include <bitset>
#include <iostream>

int main()
{
	std::cout << (std::bitset<4>{ 0b0101 } | std::bitset<4>{ 0b0110 }) << '\n';

	return 0;
}

Wypisuje:

0111

Możemy zrobić to samo, aby złożyć bitowe wyrażenia OR, takie jak 0b0111 | 0b0011 | 0b0001. Jeśli którykolwiek z bitów w kolumnie to 1, wynikiem tej kolumny jest 1:

0 1 1 1 OR
0 0 1 1 OR
0 0 0 1
--------
0 1 1 1

Oto kod powyższego:

#include <bitset>
#include <iostream>

int main()
{
	std::cout << (std::bitset<4>{ 0b0111 } | std::bitset<4>{ 0b0011 } | std::bitset<4>{ 0b0001 }) << '\n';

	return 0;
}

Wypisuje:

0111

Bitowe AND

Bitowe AND (&) działa podobnie do powyższego, z tą różnicą, że używa logiki AND zamiast logiki OR. Oznacza to, że dla każdej pary bitów w operandach funkcja Bitowe ORAZ ustawia wynikowy bit na true (1), jeśli oba sparowane bity są 1, I false (0). W przeciwnym razie.

Rozważ wyrażenie 0b0101 & 0b0110. Wyrównanie każdego bitu i zastosowanie bitowego AND do każdej kolumny bitów:

0 1 0 1 AND
0 1 1 0
--------
0 1 0 0

#include <bitset>
#include <iostream>

int main()
{
	std::cout << (std::bitset<4>{ 0b0101 } & std::bitset<4>{ 0b0110 }) << '\n';

	return 0;
}

Wypisuje:

0100

Podobnie możemy zrobić to samo, aby złożyć wyrażenia bitowe AND, takie jak 0b0001 & 0b0011 & 0b0111. Jeśli wszystkie bity w kolumnie są 1, wynikiem tej kolumny jest 1.

0 0 0 1 AND
0 0 1 1 AND
0 1 1 1
--------
0 0 0 1

#include <bitset>
#include <iostream>

int main()
{
	std::cout << (std::bitset<4>{ 0b0001 } & std::bitset<4>{ 0b0011 } & std::bitset<4>{ 0b0111 }) << '\n';

	return 0;
}

Wypisuje:

0001

Bitowego XOR

Ostatni operator to bitowego XOR (^), znany również jako wyłączny lub.

Dla każdej pary bitów w operandach Bitwise XOR ustawia wynikowy bit na true (1), gdy dokładnie jeden z sparowanych bitów jest 1, I false (0) w przeciwnym razie. Innymi słowy, Bitwise XOR ustawia wynikowy bit na true kiedy sparowane bity są różne (jeden to a 0 a drugi a 1).

Rozważ wyrażenie 0b0110 ^ 0b0011:

0 1 1 0 XOR
0 0 1 1
-------
0 1 0 1

Możliwe jest również oszacowanie stylu kolumny złożonego wyrażenia XOR, takiego jak 0b0001 ^ 0b0011 ^ 0b0111. Jeśli w kolumnie jest parzysta liczba 1 bitów, wynikiem są 0. Jeśli w kolumnie znajduje się nieparzysta liczba 1 bitów, wynikiem są 1.

0 0 0 1 XOR
0 0 1 1 XOR
0 1 1 1
--------
0 1 0 1

Bitowe operatory przypisania

Podobnie jak arytmetyczne operatory przypisania, C++ udostępnia bitowe operatory przypisania. Modyfikują one lewy operand.

Na przykład zamiast pisać x = x >> 1; można napisać x >>= 1;.

#include <bitset>
#include <iostream>

int main()
{
    std::bitset<4> bits { 0b0100 };
    bits >>= 1;
    std::cout << bits << '\n';

    return 0;
}

Ten program wypisuje:

0010

Operatory bitowe wykonują promocję całkową na mniejszych typach całkowitych Zaawansowane

Jeśli operand(y) operatora bitowego są typem całkowitym mniejszym niż int, te operandy zostaną promowane (konwertowane) do int lub unsigned int, a zwrócony wynik będzie również int lub unsigned int. Na przykład, jeśli nasze operandy to unsigned short, zostaną one awansowane (konwertowane) na unsigned int, a wynik operacji zostanie zwrócony jako unsigned int.

W wielu przypadkach nie będzie to miało znaczenia.

Jednak w przypadku używania operatorów bitowych na węższych typach całkowitych niż int lub unsigned int, należy zwrócić uwagę na dwa przypadki:

• operator~ i operator<< są wrażliwe na szerokość i mogą dawać różne wyniki w zależności od szerokości operandu.
• Inicjowanie lub przypisanie wyniku do zmiennej o mniejszym typie całkowitym jest konwersją zawężającą (ponieważ konwersja int lub unsigned int na mniejszy typ całkowity może spowodować utratę danych). Jest to niedozwolone podczas inicjalizacji listy i Twój kompilator może narzekać na zawężanie przypisania lub nie.

W poniższym programie występują następujące problemy (przy założeniu 32-bitowych wartości całkowitych):

#include <bitset>
#include <cstdint>
#include <iostream>

int main()
{
    std::uint8_t c { 0b00001111 };
    
    std::cout << std::bitset<32>(~c) << '\n';     // incorrect: prints 11111111111111111111111111110000
    std::cout << std::bitset<32>(c << 6) << '\n'; // incorrect: prints 0000000000000000001111000000
    std::uint8_t cneg { ~c };                     // error: narrowing conversion from unsigned int to std::uint8_t
    c = ~c;                                       // possible warning: narrowing conversion from unsigned int to std::uint8_t
 
    return 0;
}

Problemy te można rozwiązać, używając static_cast do konwersji wyniku operacji bitowej z powrotem na węższy typ całkowity. Poniższy program daje poprawne wyniki:

#include <bitset>
#include <cstdint>
#include <iostream>

int main()
{
    std::uint8_t c { 0b00001111 };

    std::cout << std::bitset<32>(static_cast<std::uint8_t>(~c)) << '\n';     // correct: prints 00000000000000000000000011110000
    std::cout << std::bitset<32>(static_cast<std::uint8_t>(c << 6)) << '\n'; // correct: prints 0000000000000000000011000000
    std::uint8_t cneg { static_cast<std::uint8_t>(~c) };                     // compiles
    c = static_cast<std::uint8_t>(~c);                                       // no warning
 
    return 0;
}

Streszczenie

Podsumowując, jak oceniać operacje bitowe przy użyciu metody kolumnowej:

Podczas obliczania bitowego LUB, jeśli dowolny bit w kolumnie wynosi 1, wynikiem dla tej kolumny jest 1.
Podczas obliczania bitowego ORAZ, jeśli wszystkie bity w kolumnie mają wartość 1, wynikiem dla tej kolumny jest 1.
Podczas obliczania bitowego XOR, jeśli w kolumnie znajduje się nieparzysta liczba 1 bitów, wynikiem dla tej kolumny jest 1.

W następnej lekcji odkryjemy, jak można użyć tych operatorów w połączeniu z maskami bitowymi, aby ułatwić manipulację bitami.

Czas quizu

Pytanie nr 1

a) Do czego równa się wartość 0110 >> 2 w formacie binarnym?

Pokaż rozwiązanie

b) Do czego w systemie binarnym odnosi się następujący zapis: 0011 | 0101?

Pokaż rozwiązanie

0 0 1 1 OR
0 1 0 1
--------
0 1 1 1

c) Co w systemie binarnym oznacza następujący zapis: 0011 i 0101?

Pokaż rozwiązanie

0 0 1 1 AND
0 1 0 1
--------
0 0 0 1

d) Do czego można porównać w systemie binarnym (0011 | 0101) i 1001?

Pokaż rozwiązanie

Inside the parenthesis:

0 0 1 1 OR
0 1 0 1
--------
0 1 1 1

Then:

0 1 1 1 AND
1 0 0 1
--------
0 0 0 1

Pytanie nr 2

Obrót bitowy przypomina przesunięcie bitowe, z tą różnicą, że bity przesunięte z jednego końca są dodawane z powrotem na drugi koniec. Na przykład 0b1001 << 1 byłoby 0b0010, ale obrót w lewo o 1 skutkowałby zamiast tego 0b0011 . Zaimplementuj funkcję, która wykonuje obrót w lewo na std::bitset<4>. W tym przypadku dobrze jest użyć test() i set().

Należy wykonać następujący kod:

#include <bitset>
#include <iostream>

// "rotl" stands for "rotate left"
std::bitset<4> rotl(std::bitset<4> bits)
{
// Your code here
}

int main()
{
	std::bitset<4> bits1{ 0b0001 };
	std::cout << rotl(bits1) << '\n';

	std::bitset<4> bits2{ 0b1001 };
	std::cout << rotl(bits2) << '\n';

	return 0;
}

i wydrukować następujący tekst:

0010
0011

Pokaż rozwiązanie

#include <bitset>
#include <iostream>

std::bitset<4> rotl(std::bitset<4> bits)
{
	// keep track of whether the leftmost bit was a 1
	const bool leftbit{ bits.test(3) };

	bits <<= 1; // do left shift (which shifts the leftmost bit off the end)

	// if the left bit was a 1
	if (leftbit)
		bits.set(0); // set the rightmost bit to a 1

	return bits;
}

int main()
{
	std::bitset<4> bits1{ 0b0001 };
	std::cout << rotl(bits1) << '\n';

	std::bitset<4> bits2{ 0b1001 };
	std::cout << rotl(bits2) << '\n';

	return 0;
}

Pytanie nr 3

Dodatkowy punkt: Powtórz quiz nr 2, ale nie używaj funkcji test i set (użyj funkcji bitowej operatory).

Pokaż wskazówkę

Pokaż wskazówkę

Pokaż rozwiązanie

#include <bitset>
#include <iostream>

// h/t to reader Chris for this solution
std::bitset<4> rotl(std::bitset<4> bits)
{
	// bits << 1 does the left shift
	// bits >> 3 handle the rotation of the leftmost bit
	return (bits<<1) | (bits>>3);
}

int main()
{
	std::bitset<4> bits1{ 0b0001 };
	std::cout << rotl(bits1) << '\n';

	std::bitset<4> bits2{ 0b1001 };
	std::cout << rotl(bits2) << '\n';

	return 0;
}