Phenquestions
Rövid áttekintés a Bitwise operátorokról
Az operátor olyan szimbólum, amely utasítja a fordítót bizonyos matematikai vagy logikai műveletek végrehajtására. A C ++ operátoroknak több típusa van, például:
- Számtani operátorok
- Logikai operátorok
- Relációs operátorok
- Feladatkezelők
- Bitenkénti operátorok
- Egyéb üzemeltetők
Az összes Bitwise operátor egyedi bit szinten működik. A bitenkénti operátor csak az egész és a karakter adattípusokra alkalmazható. Például, ha van egy egész típusú változója, amelynek mérete 32 bit, és a bitenkénti NEM műveletet alkalmazza, a bitenként NEM operátort alkalmazza mind a 32 bit. Tehát végül a változó mind a 32 bitje megfordul.
Hat különböző bitenkénti operátor érhető el a C ++ nyelven:
- Bitenkénti VAGY („|” -ként ábrázolva)
- Bitenkénti ÉS [képviselve „&” néven]
- Bitenként NEM [ábrázolva: „~”]
- Bitenként XOR [„^” -ként ábrázolva]
- Bitenkénti bal eltolás<<”]
- Bitenkénti jobbra tolás [„>>” -ként ábrázolva]
Bitenkénti VAGY Igazság táblázat
A Bitwise OR operátor akkor állít elő 1-t, ha legalább egy operandus értéke 1. Itt van az igazságtáblázat a Bitwise OR operátorhoz:
| Bit-1 | Bit-2 | Bit-1 | Bit-2 |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Bitenkénti ÉS igazság táblázat
Az AND operátor bitenként 1-et állít elő, ha mindkét operandus 1-re van állítva. Itt van az igazságtáblázat a Bitwise ÉS operátor számára:
| Bit-1 | Bit-2 | Bit-1 és Bit-2 |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Bitenként NEM Igazság Táblázat
A bitenkénti NOT operátor megfordítja az operandust. Itt van az igazságtábla a Bitwise NOT operátorhoz:
| Bit-1 | ~ 1. bit |
|---|---|
| 0 | 1 |
| 1 | 0 |
Bitenkénti XOR igazságtáblázat
A bitenkénti XOR operátor akkor és akkor állít elő 1-t, ha az egyik operandus 1-re van állítva. Itt van az igazságtáblázat a Bitwise ÉS operátor számára:
| Bit-1 | Bit-2 | Bit-1 ^ Bit-2 |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Bitenkénti bal váltáskezelő
Bitenkénti bal váltás operátor eltolja az összes bitet a megadott számú megadott bit mellett. Ha balra tolta az adatok összes bitjét 1-gyel, akkor az eredeti adatot megszorozza 2-vel. Hasonlóképpen, ha balra tolja az adatok összes bitjét 2-vel, akkor az eredeti adatokat megszorozzuk 4-gyel.
Bitenkénti jobb váltáskezelő
A bitenkénti jobb váltás operátor az összes bitet jobbra tolja a megadott számú megadott bitrel. Ha jobbra tolja az adatok összes bitjét 1-gyel, akkor az eredeti adatokat 2-vel osztják el (egész osztás). Hasonlóképpen, ha jobbra tolja az adatok összes bitjét 2-vel, akkor az eredeti adatokat elosztjuk (egész osztás) 4-gyel.
Példák
Most, hogy megértettük a bitenkénti műveletek alapfogalmát, nézzünk meg néhány példát, amelyek segítenek megérteni a bitenkénti műveleteket a C ++ nyelven:
- 1. példa: Bitenként vagy Vezérlő
- 2. példa: Bitenkénti ÉS operátor
- 3. példa: Bitenként NEM kezelő
- 4. példa: Bitenként XOR operátor
- 5. példa: Bitenkénti bal váltáskezelő
- 6. példa: Bitenkénti jobbra váltás kezelője
- 7. példa: Bit beállítása
- 8. példa: Tiszta bit
A 7. és 8. példa a bitenkénti operátorok valós használatának bemutatására szolgál a C ++ programozási nyelven.
1. példa: Bitenként VAGY operátor
Ebben a példaprogramban bemutatjuk a Bitwise OR operátort.
#include#include
#include
névtér használata std;
// display () függvény
void display (string print_msg, int szám)
bitset<16> myBitSet (szám);
cout << print_msg;
cout << myBitSet.to_string() << " (" << myBitSet.to_ulong() << ") " << endl;
int main ()
int első_szám = 7, második_szám = 9, eredmény = 0;
// Bitenként VAGY művelet
eredmény = első_szám | second_num;
// kinyomtatja a bemeneti számokat
cout << endl;
display ("Az első szám =", első_szám);
kijelző ("A második szám =", második_szám);
// kinyomtatja a kimeneti értéket
display ("első_szám | második_szám =", eredmény);
cout << endl;
visszatér 0;
2. példa: Bitenkénti ÉS operátor
Ebben a példaprogramban bemutatjuk a Bitwise AND operátort.
#include#include
#include
névtér használata std;
// display () függvény
void display (string print_msg, int szám)
bitset<16> myBitSet (szám);
cout << print_msg;
cout << myBitSet.to_string() << " (" << myBitSet.to_ulong() << ") " << endl;
int main ()
int első_szám = 7, második_szám = 9, eredmény = 0;
// Bitenkénti ÉS művelet
eredmény = első_szám & második_szám;
// kinyomtatja a bemeneti számokat
cout << endl;
display ("Az első szám =", első_szám);
szórás ("A második szám =", második_szám);
// kinyomtatja a kimeneti értéket
display ("első_szám & második_szám =", eredmény);
cout << endl;
visszatér 0;
3. példa: Bitenként NEM kezelő
Ebben a példaprogramban megértjük, hogyan működik a Bitwise NOT operátor C-ben++.
#include#include
#include
névtér használata std;
// display () függvény
void display (string print_msg, int szám)
bitset<16> myBitSet (szám);
cout << print_msg;
cout << myBitSet.to_string() << " (" << myBitSet.to_ulong() << ") " << endl;
int main ()
int első_szám = 7, második_szám = 9, eredmény_1 = 0, eredmény_2 = 0;
// Bitenként NEM művelet
eredmény_1 = ~ első_szám;
eredmény_2 = ~ másodperc_szám;
// kinyomtatja a bemeneti számokat és a kimeneti értéket
cout << endl;
display ("Az első szám =", első_szám);
display ("~ first_num =", eredmény_1);
cout << endl;
// kinyomtatja a bemeneti számokat és a kimeneti értéket
kijelző ("A második szám =", második_szám);
display ("~ másodperc_szám =", eredmény_2);
cout << endl;
visszatér 0;
4. példa: Bitenként XOR operátor
Ez a program elmagyarázni kívánja, hogy a Bitwise XOR operátor hogyan működik C-ben++.
#include#include
#include
névtér használata std;
// display () függvény
void display (string print_msg, int szám)
bitset<16> myBitSet (szám);
cout << print_msg;
cout << myBitSet.to_string() << " (" << myBitSet.to_ulong() << ") " << endl;
int main ()
int első_szám = 7, második_szám = 9, eredmény = 0;
// Bitenként XOR művelet
eredmény = első_szám ^ második_szám;
// kinyomtatja a bemeneti számokat
cout << endl;
display ("Az első szám =", első_szám);
kijelző ("A második szám =", második_szám);
// kinyomtatja a kimeneti értéket
display ("első_szám ^ második_szám =", eredmény);
cout << endl;
visszatér 0;
5. példa: Bitenkénti bal váltáskezelő
Most látni fogjuk a Bitenkénti bal váltás operátor példáját. Ebben a programban két számot deklaráltunk, az első_szám és a második_szám egész típusú. Itt az „first_num” balra tolódik egy bitrel, a „second_num” pedig két bit balra tolódik.
#include#include
#include
névtér használata std;
// display () függvény
void display (string print_msg, int szám)
bitset<16> myBitSet (szám);
cout << print_msg;
cout << myBitSet.to_string() << " (" << myBitSet.to_ulong() << ") " << endl;
int main ()
int első_szám = 7, második_szám = 9, eredmény_1 = 0, eredmény_2 = 0;
// Bitenkénti bal váltás művelet
eredmény_1 = első_szám << 1;
eredmény_2 = második_szám << 2;
// kinyomtatja a bemeneti számokat és a kimeneti értéket
cout << endl;
display ("Az első szám =", első_szám);
display ("első_szám << 1 = ", result_1);
cout << endl;
// kinyomtatja a bemeneti számokat és a kimeneti értéket
kijelző ("A második szám =", második_szám);
display ("második_szám << 2 = ", result_2);
cout << endl;
visszatér 0;
6. példa: Bitenkénti jobbra váltás kezelője
Most egy másik példát fogunk látni a Bitwise Right Shift operátor megértéséhez. Két számot deklaráltunk, az első_szám és a második_szám egész típusú. Itt az „first_num” jobbra tolódik egy bittel, a „second_num” pedig két bittel jobbra.
#include#include
#include
névtér használata std;
// display () függvény
void display (string print_msg, int szám)
bitset<16> myBitSet (szám);
cout << print_msg;
cout << myBitSet.to_string() << " (" << myBitSet.to_ulong() << ") " << endl;
int main ()
int első_szám = 7, második_szám = 9, eredmény_1 = 0, eredmény_2 = 0;
// Bitenkénti jobb váltás művelet
eredmény_1 = első_szám >> 1;
eredmény_2 = második_szám >> 2;
// kinyomtatja a bemeneti számokat és a kimeneti értéket
cout << endl;
display ("Az első szám =", első_szám);
display ("első_szám >> 1 =", eredmény_1);
cout << endl;
// kinyomtatja a bemeneti számokat és a kimeneti értéket
kijelző ("A második szám =", második_szám);
display ("második_szám >> 2 =", eredmény_2);
cout << endl;
visszatér 0;
7. példa: Bit beállítása
Ez a példa bemutatni kívánja, hogyan állítson be egy adott bitet bitenként operátorok segítségével.
#include#include
#include
névtér használata std;
// display () függvény
void display (string print_msg, int szám)
bitset<16> myBitSet (szám);
cout << print_msg;
cout << myBitSet.to_string() << " (" << myBitSet.to_ulong() << ") " << endl;
int main ()
int első_szám = 7, második_szám = 9;
// kinyomtatja a beviteli számot - first_num
cout << endl;
display ("Az első szám =", első_szám);
// Állítsa be az 5. bitet
első_szám | = (1UL << 5);
// Kimenet nyomtatása
display ("Állítsa be az első_szám = 5. bitjét", első_szám);
cout << endl;
// kinyomtatja a bemeneti számot - second_num
cout << endl;
display ("A második szám =", második_szám); // Állítsa be a 6. bitet
second_num | = (1UL << 6);
// Kimenet nyomtatása
display ("Állítsa be a második_szám = 6. bitjét", második_szám);
cout << endl;
visszatér 0;
8. példa: Tiszta bit
Ez a példa azt kívánja bemutatni, hogyan lehet egy adott bitet törölni bitenként operátorok segítségével.
#include#include
#include
névtér használata std;
// display () függvény
void display (string print_msg, int szám)
bitset<16> myBitSet (szám);
cout << print_msg;
cout << myBitSet.to_string() << " (" << myBitSet.to_ulong() << ") " << endl;
int main ()
int első_szám = 7, második_szám = 9;
// kinyomtatja a beviteli számot - first_num
cout << endl;
display ("Az első szám =", első_szám);
// 2. bit törlése
első_szám & = ~ (1UL << 2);
// Nyomtatási kimenet
display ("Állítsa be a first_num = 2. bitjét", first_num);
cout << endl;
// kinyomtatja a bemeneti számot - second_num
cout << endl;
kijelző ("A második szám =", második_szám);
// 3. bit törlése
másodperc_szám & = ~ (1UL << 3);
// Nyomtatási kimenet
display ("Állítsa be a második_num = 3. bitjét", második_szám);
cout << endl;
visszatér 0;
Következtetés
A bitenkénti operátort elsősorban az egyes bitek manipulálására használják egész szám és karakter adattípus esetén. A bitenkénti operátort erősen használják a beágyazott szoftverek fejlesztésében. Tehát, ha eszközillesztőt vagy a hardverszinthez nagyon közel álló rendszert fejleszt, érdemes ezeket a bitenkénti operátorokat használni.
