Kako postavljate, brišete i mijenjate jedan bit?

Kako postavljate, brišete i prebacujete bitove u C / C ++?

2210
07 сент. postavio / la JeffV 07 sept. 2008-09-07 03:42 '08 u 3:42 2008-09-07 03:42
@ 27 odgovora

Postavljanje bitova

Koristite bitovni OR operator ( | ) za postavljanje bita.

 number |= 1UL << n; 

To će postaviti n bit number . n mora biti nula ako želite postaviti prvi bit i tako dalje na n-1 ako želite postaviti n bit.

Ako je number veći od unsigned long , upotrijebite 1ULL ; promocija 1UL << n nastupa tek nakon procjene 1UL << n gdje se nedefinirano ponašanje mijenja više od širine. Isto vrijedi i za sve druge primjere.

Bitovi za čišćenje

Koristite operator bit () da obrišete bit.

 number  ~(1UL << n); 

Time ćete obrisati n dio number . Morate invertirati bitni niz s bitovskim NE ( ~ ) operatorom, a zatim s njim.

Pomakni se malo

XOR operator ( ^ ) se može koristiti za prebacivanje bitova.

 number ^= 1UL << n; 

Time se mijenja n bit number .

Provjerite bit

Nisi to tražio, ali ja bih to mogao dodati.

Da biste provjerili malo, pomaknite broj n u desno, a zatim bitno.

 bit = (number >> n)  1U; 

To će staviti vrijednost n bita number u bit varijablu.

Promijenite nth bit u x

Postavljanje n bita na 1 ili 0 može se postići korištenjem sljedeće implementacije 2 dodatka C ++:

 number ^= (-x ^ number)  (1UL << n); 

n bit će postavljen ako je x jednako 1 i briše se ako je x 0 . Ako x ima drugačije značenje, dobivate smeće. x = !!x će biti boolean na 0 ili 1.

Da bi ovo bilo neovisno o ponašanju add-on 2 dodataka (gdje -1 ima sve skupove bitova, za razliku od implementacije 1 dodatka ili C ++ znaka / vrijednosti), upotrijebite nepotpisanu negaciju.

 number ^= (-(unsigned long)x ^ number)  (1UL << n); 

ili

 unsigned long newbit = !!x; // Also booleanize to force 0 or 1 number ^= (-newbit ^ number)  (1UL << n); 

Obično je dobra ideja koristiti nepotpisane vrste za prijenosnu manipulaciju bitovima.

Općenito je dobra ideja ne kopirati / zalijepiti kôd kao cjelinu, te stoga mnogi ljudi koriste makroe predprocesora (na primjer, odgovor iz wiki zajednice ispod ) ili neku vrstu enkapsulacije.

3179
07 сент. Odgovor dao Jeremy Ruten 7. rujna 2008-09-07 03:50 '08 u 3:50 am 2008-09-07 03:50

Korištenje standardne C ++ biblioteke: std::bitset<N> .

Ili Boost : boost::dynamic_bitset .

Ne morate se valjati:

 #include <bitset> #include <iostream> int main() { std::bitset<5> x; x[1] = 1; x[2] = 0; // Note x[0-4] valid std::cout << x << std::endl; } 

 [Alpha:] > ./a.out 00010 

Verzija Boost omogućuje vam da postavite bit na veličinu bita u usporedbi sa standardnom brzinom bita.

405
18 сент. Odgovor dao Martin York 18. rujna 2008-09-18 03:34 '08 u 3:34 am 2008-09-18 03:34

Druga mogućnost je korištenje bitnih polja:

 struct bits { unsigned int a:1; unsigned int b:1; unsigned int c:1; }; struct bits mybits; 

definira 3-bitno polje (zapravo, to su tri jednobitna polja). Bitne operacije postaju malo (haha) lakše:

Da biste postavili ili izbrisali bit:

 mybits.b = 1; mybits.c = 0; 

Da biste promijenili bit:

 mybits.a = !mybits.a; mybits.b = ~mybits.b; mybits.c ^= 1;  

Bit provjere:

 if (mybits.c) //if mybits.c is non zero the next line below will execute 

Ovo radi samo s bitfieldovima fiksne veličine. Inače ćete morati pribjeći bit-twist metodama opisanim u prethodnim porukama.

224
11 сент. Odgovor daje Ferruccio 11 sep. 2008-09-11 03:56 '08 u 3:56 am 2008-09-11 03:56

Koristim makronaredbe definirane u datoteci zaglavlja za upravljanje postavljenim bitovima i jasnim:

  #define BIT_SET(a,b) ((a) |= (1ULL<<(b))) #define BIT_CLEAR(a,b) ((a)  ~(1ULL<<(b))) #define BIT_FLIP(a,b) ((a) ^= (1ULL<<(b))) #define BIT_CHECK(a,b) (!!((a)  (1ULL<<(b)))) // '!!' to make sure this returns 0 or 1  #define BITMASK_SET(x,y) ((x) |= (y)) #define BITMASK_CLEAR(x,y) ((x)  (~(y))) #define BITMASK_FLIP(x,y) ((x) ^= (y)) #define BITMASK_CHECK_ALL(x,y) (((x)  (y)) == (y)) // warning: evaluates y twice #define BITMASK_CHECK_ANY(x,y) ((x)  (y)) 
138
05 нояб. Odgovor daje Steve Karg 05 Nov. 2008-11-05 01:35 '08 u 1:35 am 2008-11-05 01:35

Ponekad je vrijedno koristiti enum za označavanje bitova:

 enum ThingFlags = { ThingMask = 0x0000, ThingFlag0 = 1 << 0, ThingFlag1 = 1 << 1, ThingError = 1 << 8, } 

Zatim kasnije koristite imena. To znači pisati

 thingstate |= ThingFlag1; thingstate  ~ThingFlag0; if (thing  ThingError) {...} 

instalirati, očistiti i provjeriti. Na taj način sakrijete čarobne brojeve od ostatka koda.

Osim toga, podržavam Jeremyjevu odluku.

106
09 сент. odgovor je dmckee 09 Sep. 2008-09-09 00:07 '08 u 0:07 2008-09-09 00:07

Iz snip-c.zip bitops.h:

  typedef enum {ERROR = -1, FALSE, TRUE} LOGICAL; #define BOOL(x) (!(!(x))) #define BitSet(arg,posn) ((arg) | (1L << (posn))) #define BitClr(arg,posn) ((arg)  ~(1L << (posn))) #define BitTst(arg,posn) BOOL((arg)  (1L << (posn))) #define BitFlp(arg,posn) ((arg) ^ (1L << (posn))) 

Pa, neka analizira stvari ...

Opći izraz s kojim imate problema u svim tim slučajevima je "(1L << (posn))". Sve ovo stvara masku s jednim bitom i to će raditi s bilo kojim cjelobrojnim tipom. Argument "posn" označava položaj u kojem želite bit. Ako je posn == 0, tada će se ovaj izraz ocjenjivati ​​kao:

  0000 0000 0000 0000 0000 0000 0000 0001 binary. 

Ako je posn == 8, on će procijeniti

  0000 0000 0000 0000 0000 0001 0000 0000 binary. 

Drugim riječima, jednostavno kreira polje 0 s 1 u navedenom položaju. Jedini lukav dio je u BitClr () makrou, gdje trebamo postaviti jedan bit 0 bit u polje 1. To se postiže dodavanjem jednog u isti izraz, koji je označen operatorom tilda (~).

Čim se maska ​​kreira, ona se primjenjuje na argument na isti način kao što pretpostavljate, koristeći bitni i ( ili (|) i xor (^) operatore. Budući da je maska ​​duge, makronaredbe će funkcionirati jednako dobro kao i za znakove char, short, int ili long.

Zaključak je da je to uobičajeno rješenje za čitavu klasu problema. Naravno, moguće je i čak preporučljivo prepisati ekvivalent bilo kojeg od ovih makronaredbi s eksplicitnim vrijednostima maske svaki put kada vam je potrebna, ali zašto to učiniti? Zapamtite da se makro supstitucija odvija u predprocesoru i stoga će generirani kod odražavati činjenicu da se kompajler smatra da su vrijednosti konstantne, tj. Također je učinkovito koristiti generalizirane makronaredbe kako biste "izmislili točak" svaki put kada trebate napraviti malu manipulaciju.

Uvjeren? Ovdje je neki test kod - koristio sam Watcom C s potpunom optimizacijom i bez korištenja _cdecl, tako da bi rezultirajuća demontaža bila što čišća:

---- [TEST.C] ----------------------------------------- -----------------------

 #define BOOL(x) (!(!(x))) #define BitSet(arg,posn) ((arg) | (1L << (posn))) #define BitClr(arg,posn) ((arg)  ~(1L << (posn))) #define BitTst(arg,posn) BOOL((arg)  (1L << (posn))) #define BitFlp(arg,posn) ((arg) ^ (1L << (posn))) int bitmanip(int word) { word = BitSet(word, 2); word = BitSet(word, 7); word = BitClr(word, 3); word = BitFlp(word, 9); return word; } 

---- [TEST.OUT (rastavljen)] ---------------------------------------------- ---------

 Module: C:\BINK\tst.c Group: 'DGROUP' CONST,CONST2,_DATA,_BSS Segment: _TEXT BYTE 00000008 bytes 0000 0c 84 bitmanip_ or al,84H ; set bits 2 and 7 0002 80 f4 02 xor ah,02H ; flip bit 9 of EAX (bit 1 of AH) 0005 24 f7 and al,0f7H 0007 c3 ret No disassembly errors 

---- [finis] ------------------------------------------- ----------------------

40
17 сент. odgovor dao yogeesh na 17 sep . 2008-09-17 05:04 '08 u 5:04 am 2008-09-17 05:04

Koristite bitne operatore: > |

Za postavljanje zadnjeg bita u 000b :

 foo = foo | 001b 

Da biste provjerili zadnji bit u foo :

 if ( foo  001b ) .... 

Da biste izbrisali zadnji bit u foo :

 foo = foo  110b 

Zbog jasnoće, koristio sam XXXb . Vjerojatno ćete raditi s HEX pogledom, ovisno o strukturi podataka u kojoj pakirate bitove.

31
07 сент. Odgovor je dao nsanders Sep 07 2008-09-07 03:45 '08 u 3:45 2008-09-07 03:45

Za novorođenca, želim objasniti još neki primjer:

primjer:

 value is 0x55; bitnum : 3rd. 

Operator > se koristi za provjeru bita:

 0101 0101  0000 1000 ___________ 0000 0000 (mean 0: False). It will work fine if the third bit is 1 (then the answer will be True) 

Uključi / isključi ili okreni:

 0101 0101 ^ 0000 1000 ___________ 0101 1101 (Flip the third bit without affecting other bits) 
operater

| : postavite bit

 0101 0101 | 0000 1000 ___________ 0101 1101 (set the third bit without affecting other bits) 
31
05 июня '12 в 17:18 2012-06-05 17:18 odgovor je dao kapilddit na Lipanj 05 '12 u 17:18 2012-06-05 17:18

Ovo je moja najdraža aritmetička makronaredba bita, koja radi za bilo koju vrstu nepotpisanog cjelobrojnog niza od unsigned char do size_t (koji je najveći tip koji bi trebao biti učinkovit za rad):

 #define BITOP(a,b,op) \ ((a)[(size_t)(b)/(8*sizeof *(a))] op ((size_t)1<<((size_t)(b)%(8*sizeof *(a))))) 

Za postavljanje bita:

 BITOP(array, bit, |=); 

Da biste izbrisali bit:

 BITOP(array, bit, > 

Da biste promijenili bit:

 BITOP(array, bit, ^=); 

Da biste provjerili bit:

 if (BITOP(array, bit,  ... 

i drugi

26
13 июля '10 в 9:53 2010-07-13 09:53 Odgovor daje R .. 13. srpnja '10 u 9:53 2010-07-13 09:53

Budući da je ovo označeno "ugrađen", pretpostavljam da koristite mikrokontroler. Svi gore navedeni prijedlozi važe i rade (read-modify-write, union, structs, itd.).

Međutim, tijekom osciloskop-based izazov, bio sam zaprepašteni da otkrijete da su te metode imaju značajan pretek u ciklusu procesora u odnosu na pisanje vrijednosti izravno na mikro PORTnSET / PORTnCLEAR registara, što čini stvarnu razliku gdje postoje ISR petlje / visoke frekvencije prebacivanje kontakata ,

Za one koji nisu upoznati: U mom primjeru, mikro ima opći registar PORTn, koji prikazuje izlazne igle, tako da PORTn | = BIT_TO_SET dovodi do read-modify-write u ovaj registar. Međutim, PORTnSET / PORTnCLEAR registri su postavljeni na "1", što znači "molim vas da ovaj bit 1" (SET) ili "molimo vas da ovaj bit nula" (CLEAR) i "0" znači "ostavite jedan izlaz". dakle, dobivate dva porta, ovisno o tome instalirate ili brišete bit (nije uvijek zgodan), ali reagirate mnogo brže i smanjite prikupljeni kod.

23
14 июня '12 в 18:23 2012-06-14 18:23 Odgovor je dao John U 14. lipnja 2012. u 18:23 sati

Primijenjeni pristup ima i druge prednosti u ugrađenom prostoru. Možete definirati strukturu koja izravno mapira u bitove u određenom hardverskom registru.

 struct HwRegister { unsigned int errorFlag:1; // one-bit flag field unsigned int Mode:3; // three-bit mode field unsigned int StatusCode:4; // four-bit status code }; struct HwRegister CR3342_AReg; 

Morate znati red za pakiranje bitova: u početku mislim da je to MSB, ali to može ovisiti o implementaciji. Također, provjerite kako polja polaznika vaših rukovaoca prelaze granice bajtova.

Tada možete čitati, pisati, testirati pojedinačne vrijednosti, kao i prije.

22
06 нояб. odgovor je dao Roddy 06. studenog. 2008-11-06 14:30 '08 u 14:30 2008-11-06 14:30

Uobičajenije za bitmap slike proizvoljne veličine:

 #define BITS 8 #define BIT_SET( p, n) (p[(n)/BITS] |= (0x80>>((n)%BITS))) #define BIT_CLEAR(p, n) (p[(n)/BITS]  ~(0x80>>((n)%BITS))) #define BIT_ISSET(p, n) (p[(n)/BITS]  (0x80>>((n)%BITS))) 
19
14 июня '09 в 0:27 2009-06-14 00:27 odgovor je dat račun 14. lipnja '09 u 0:27 2009-06-14 00:27

Provjerite bit na proizvoljnom mjestu u varijabli proizvoljnog tipa:

 #define bit_test(x, y) ( ( ((const char*)  0x80 >> ((y) >> (7-((y) ) ) 

Koristeći primjer:

 int main(void) { unsigned char arr[8] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF }; for (int ix = 0; ix < 64; ++ix) printf("bit %d is %d\n", ix, bit_test(arr, ix)); return 0; } 

Napomene: Dizajnirana je da bude brza (s obzirom na fleksibilnost) i ne razgranata. To dovodi do učinkovitog SPARC koda prilikom kompilacije Sun Studio 8; Također sam ga testirao koristeći MSVC ++ 2008 na amd64. Možete stvoriti slične makronaredbe za postavljanje i čišćenje bitova. Ključna razlika ovog rješenja u odnosu na mnoge druge ovdje je da radi za bilo koju lokaciju u gotovo bilo kojoj vrsti varijable.

18
04 янв. Odgovor je dao John Zwinck 04. siječnja 2009-01-04 02:44 '09 u 2:44 2009-01-04 02:44

Ako radite mnogo bitova, možete koristiti maske koje će sve to ubrzati. Sljedeće funkcije su vrlo brze i još uvijek fleksibilne (dopuštaju preklapanje bitova u bitmapama bilo koje veličine).

 const unsigned char TQuickByteMask[8] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, };  void TSetBit( short bit, unsigned char *bitmap) { short n, x; x = bit / 8; // Index to byte. n = bit % 8; // Specific bit in byte. bitmap[x] |= TQuickByteMask[n]; // Set bit. }  void TResetBit( short bit, unsigned char *bitmap) { short n, x; x = bit / 8; // Index to byte. n = bit % 8; // Specific bit in byte. bitmap[x]  (~TQuickByteMask[n]); // Reset bit. }  void TToggleBit( short bit, unsigned char *bitmap) { short n, x; x = bit / 8; // Index to byte. n = bit % 8; // Specific bit in byte. bitmap[x] ^= TQuickByteMask[n]; // Toggle bit. }  short TIsBitSet( short bit, const unsigned char *bitmap) { short n, x; x = bit / 8; // Index to byte. n = bit % 8; // Specific bit in byte. // Test bit (logigal AND). if (bitmap[x]  TQuickByteMask[n]) return 1; return 0; }  short TIsBitReset( short bit, const unsigned char *bitmap) { return TIsBitSet(bit, bitmap) ^ 1; }  int TCountBits( const unsigned char *bitmap, int size) { int i, count = 0; for (i=0; i<size; i++) if (TIsBitSet(i, bitmap)) count++; return count; } 

Napomena: da postavite 'n' bit na 16-bitni cijeli broj, učinite sljedeće:

 TSetBit( n, > 

Na vama je da se uvjerite da je bitni broj unutar raspona bit kartice koju prenosite. Imajte na umu da za male endian procesore, koji su bajtovi, riječi, riječi, riječi itd. Ispravno se međusobno prikazujete u memoriji (glavni razlog zašto su mali endian procesori bolji od procesora velikog broja, oh, osjećam da se počinje vatreni rat ...).

14
17 сент. Odgovor daje Tim Ring 17. rujna. 2008-09-17 17:10 '08 u 17:10 2008-09-17 17:10

Ovaj program namijenjen je promjeni bilo kojeg bita podataka od 0 do 1 ili od 1 do 0:

 { unsigned int data = 0x000000F0; int bitpos = 4; int bitvalue = 1; unsigned int bit = data; bit = (bit>>bitpos) int invbitvalue = 0x00000001 printf("%x\n",bit); if (bitvalue == 0) { if (bit == 0) printf("%x\n", data); else { data = (data^(invbitvalue<<bitpos)); printf("%x\n", data); } } else { if (bit == 1) printf("elseif %x\n", data); else { data = (data|(bitvalue<<bitpos)); printf("else %x\n", data); } } } 
13
28 февр. odgovor je dao Gokul Naathan 28. veljače. 2012-02-28 22:27 '12 u 10:27 pm 2012-02-28 22:27

Koristite ovo:

 int ToggleNthBit ( unsigned char n, int num ) { if(num  (1 << n)) num  ~(1 << n); else num |= (1 << n); return num; } 
11
12 апр. Odgovoriti thangavel 12. tra 2009-04-12 02:05 '09 u 2:05 am 2009-04-12 02:05

bitset proširenje odgovora:

 #include <iostream> #include <bitset> #include <string> using namespace std; int main() { bitset<8> byte(std::string("10010011"); // Set Bit byte.set(3); // 10010111 // Clear Bit byte.reset(2); // 10010101 // Toggle Bit byte.flip(7); // 00010101 cout << byte << endl; return 0; } 
10
08 мая '14 в 7:33 2014-05-08 07:33 odgovor je dao kendotwill 08 Svibanj '14 u 7:33 2014-05-08 07:33

Ako želite izvršiti ovu operaciju s C programiranjem u Linux kernelu, predlažem da koristite standardne Linux kernel API-je.

Pogledajte https://www.kernel.org/doc/htmldocs/kernel-api/ch02s03.html.

 set_bit Atomically set a bit in memory clear_bit Clears a bit in memory change_bit Toggle a bit in memory test_and_set_bit Set a bit and return its old value test_and_clear_bit Clear a bit and return its old value test_and_change_bit Change a bit and return its old value test_bit Determine whether a bit is set vrijednost set_bit Atomically set a bit in memory clear_bit Clears a bit in memory change_bit Toggle a bit in memory test_and_set_bit Set a bit and return its old value test_and_clear_bit Clear a bit and return its old value test_and_change_bit Change a bit and return its old value test_bit Determine whether a bit is set 

Napomena. Ovdje se cijela operacija izvodi u jednom koraku. Stoga su svi oni zajamčeno atomski, čak i na SMP računalima i korisni kako bi se osigurala dosljednost između procesora.

10
27 мая '16 в 19:41 2016-05-27 19:41 Odgovor daje Jeegar Patel 27. svibnja '16. U 19:41 2016-05-27 19:41

Visual C 2010 i vjerojatno mnogi drugi kompilatori imaju izravnu podršku za operacije ugrađenih bitova. Iznenađujuće, radi, čak i operator sizeof () radi ispravno.

 bool IsGph[256], IsNotGph[256]; // Initialize boolean array to detect printable characters for(i=0; i<sizeof(IsGph); i++) { IsGph[i] = isgraph((unsigned char)i); } 

Dakle, na vaše pitanje IsGph [i] = 1 ili IsGph [i] = 0, pojednostavite postavljanje i čišćenje boola.

Pronađi znakove koji se ne mogu ispisati ...

 // Initialize boolean array to detect UN-printable characters, // then call function to toggle required bits true, while initializing a 2nd // boolean array as the complement of the 1st. for(i=0; i<sizeof(IsGph); i++) { if(IsGph[i]) { IsNotGph[i] = 0; } else { IsNotGph[i] = 1; } } 

Napominjemo da ovaj kôd nije ništa posebno. Obrađuje bit kao cjelinu, što je tehnički. 1-bitni cijeli broj koji može sadržavati 2 vrijednosti i samo 2 vrijednosti.

Jednom sam koristio ovaj pristup za traženje duplikata kreditnih zapisa, gdje je number_name bio ISAM ključ, koristeći 6-znamenkasti broj kredita kao indeks u bitskom nizu. Odmah i odmah, nakon 8 mjeseci, dokazao sam da je mainframe sustav iz kojeg smo dobili podatke zapravo neispravan. Jednostavnost bit-polja čini povjerenje u njihovu ispravnost vrlo visokom - primjerice, u pristupu pretraživanja.

9
30 дек. Odgovor daje korisnik1899861 30. prosinca. 2012-12-30 05:31 '12 u 5:31 AM 2012-12-30 05:31

Koristite jedan od operatora kako je ovdje definirano.

Za postavljanje bita, upotrijebite int x = x | 0x?; int x = x | 0x?; gdje ? - To je položaj bita u binarnom obliku.

6
30 апр. Odgovorite Jasonu 30. travnja 2012-04-30 09:48 '12 u 9:48 2012-04-30 09:48

Evo nekih makronaredbi koje koristim:

 SET_FLAG(Status, Flag) ((Status) |= (Flag)) CLEAR_FLAG(Status, Flag) ((Status)  ~(Flag)) INVALID_FLAGS(ulFlags, ulAllowed) ((ulFlags)  ~(ulAllowed)) TEST_FLAGS(t,ulMask, ulBit) (((t) == (ulBit)) IS_FLAG_SET(t,ulMask) TEST_FLAGS(t,ulMask,ulMask) IS_FLAG_CLEAR(t,ulMask) TEST_FLAGS(t,ulMask,0) 
5
07 февр. odgovor je dao sam msft 07. veljače. 2015-02-07 02:11 '15 u 2:11 2015-02-07 02:11

Kako postavljate, brišete i mijenjate jedan bit?

Da biste riješili problem s uobičajenom pogreškom kodiranja prilikom pokušaja stvaranja maske:
1 nije uvijek dovoljno širok

Koji problemi nastaju kada je number širi od 1 ?
x može biti prevelik za pomicanje 1 << x , što rezultira nedefiniranim ponašanjem (UB). Čak i ako x nije prevelik, ~ možda neće preokrenuti dovoljno značajnih bitova.

 // assume 32 bit int/unsigned unsigned long long number = foo(); unsigned x = 40; number |= (1 << x); // UB number ^= (1 << x); // UB number  ~(1 << x); // UB x = 10; number  ~(1 << x); // Wrong mask, not wide enough 

Osigurajte 1 dovoljno široko:

Kôd se može koristiti 1ull ili pedantically (uintmax_t)1 i optimizirati prevodilac.

 number |= (1ull << x); number |= ((uintmax_t)1 << x); 

Ili lijevanje - čini pogreške kodiranja / pregleda / održavanja uz zadržavanje točnosti i relevantnosti.

 number |= (type_of_number)1 << x; 

Ili lagano unaprijedite 1 , prisiljavajući math operaciju koja je manja od vrste number .

 number |= (number*0 + 1) << x; 

Kao i većina malo manipulacija, najbolje je raditi s nepotpisanim tipovima, a ne s potpisanim.

4
27 сент. odgovor se daje chux 27. rujna 2017-09-27 21:18 '17 u 21:18 2017-09-27 21:18

Verzija predloška C ++ 11 (smještena u zaglavlje):

 namespace bit { template <typename T1, typename T2> inline void set (T1  T2 bit) {variable |= ((T1)1 << bit);} template <typename T1, typename T2> inline void clear(T1  T2 bit) {variable  ~((T1)1 << bit);} template <typename T1, typename T2> inline void flip (T1  T2 bit) {variable ^= ((T1)1 << bit);} template <typename T1, typename T2> inline bool test (T1  T2 bit) {return variable  ((T1)1 << bit);} } namespace bitmask { template <typename T1, typename T2> inline void set (T1  T2 bits) {variable |= bits;} template <typename T1, typename T2> inline void clear(T1  T2 bits) {variable  ~bits;} template <typename T1, typename T2> inline void flip (T1  T2 bits) {variable ^= bits;} template <typename T1, typename T2> inline bool test_all(T1  T2 bits) {return ((variable  bits) == bits);} template <typename T1, typename T2> inline bool test_any(T1  T2 bits) {return variable  bits;} } 
3
10 февр. Odgovor Joakima L. Christiansena 10. veljače. 2018-02-10 23:07 '18 u 23:07 2018-02-10 23:07

Upotrijebljena varijabla

 int value, pos; 

vrijednost - podaci
pos - položaj bita koji želimo postaviti, izbrisati ili prebaciti
Postavite malo

 value = value | 1 << pos; 

Očisti malo

 value = value  ~(1 << pos); 

Toggle bit

 value = value ^ 1 << pos; 
3
11 июля '18 в 20:32 2018-07-11 20:32 odgovor je dao Jeet Parikh 11. srpnja 18. u 20:32 sati 2018-07-11 20:32
 int set_nth_bit(int num, int n){ return (num | 1 << n); } int clear_nth_bit(int num, int n){ return (num  ~( 1 << n)); } int toggle_nth_bit(int num, int n){ return num ^ (1 << n); } int check_nth_bit(int num, int n){ return num  (1 << n); } 
3
21 февр. odgovor je dao Sazzad Hissain Khan 21. veljače. 2018-02-21 15:35 '18 u 15:35 sati 2018-02-21 15:35

Za postavljanje BitIdx bita u Number na BitValue

 Number = Number xor (1 shl BitIdx) or (BitValue shl BitIdx) 

Trik je u tome da najprije bezuvjetno očistite BitIdx bit, navodeći ga s 1. Ova verzija izgleda nešto sporije nego kod grananja ( if bit = 1 then setbit else clearbit ), ali je jednostruka.

-2
22 мая '17 в 11:24 2017-05-22 11:24 odgovor je dat na Fr0sT 22. svibnja 2006. u 11:24 2017-05-22 11:24

Pokušajte jednu od C funkcija da biste promijenili n bita:

 char bitfield; // Start at 0th position void chang_n_bit(int n, int value) { bitfield = (bitfield | (1 << n))  (~( (1 << n) ^ (value << n) )); } 

ili

 void chang_n_bit(int n, int value) { bitfield = (bitfield | (1 << n))  ((value << n) | ((~0) ^ (1 << n))); } 

ili

 void chang_n_bit(int n, int value) { if(value) bitfield |= 1 << n; else bitfield  ~0 ^ (1 << n); } char get_n_bit(int n) { return (bitfield  (1 << n)) ? 1 : 0; } 
-2
27 мая '14 в 14:46 2014-05-27 14:46 odgovor se daje Vincetu 27. svibnja 2014. u 14:46 2014-05-27 14:46

Ostala pitanja o oznakama ili Postavi pitanje