Bagaimana Anda mengatur, menghapus, dan beralih satu bit?

Bagaimana Anda mengatur, menghapus, dan mengalihkan bit dalam C / C ++?

2210
07 сент. diatur oleh JeffV 07 sept. 2008-09-07 03:42 '08 pada 3:42 2008-09-07 03:42
@ 27 jawaban

Pengaturan bit

Gunakan bitwise OR operator ( | ) untuk mengatur bit.

 number |= 1UL << n; 

Ini akan mengatur bit n dari number . n harus nol jika Anda ingin mengatur bit 1 dan seterusnya ke n-1 jika Anda ingin mengatur bit n - n .

Gunakan 1ULL jika number lebih besar dari unsigned long ; promosi 1UL << n terjadi hanya setelah evaluasi 1UL << n mana perilaku tidak terdefinisi bergeser lebih dari lebar long Hal yang sama berlaku untuk semua contoh lainnya.

Membersihkan bit

Gunakan bitwise AND operator ( > ) untuk menghapus bit.

 number  ~(1UL << n); 

Ini akan menghapus bit n dari number . Anda harus membalikkan string bit dengan operator bitwise NOT ( ~ ), lalu DAN itu.

Beralih sedikit

Operator XOR ( ^ ) dapat digunakan untuk beralih bit.

 number ^= 1UL << n; 

Ini akan mengaktifkan bit n - n number .

Periksa bit

Anda tidak memintanya, tetapi saya juga bisa menambahkannya.

Untuk memeriksa sedikit, pindahkan angka n ke kanan, lalu bitwise.

 bit = (number >> n)  1U; 

Ini akan menempatkan nilai bit n - n number dalam variabel bit .

Ubah bit ke-x

Mengatur bit ke- 1 atau 0 dapat dicapai dengan menggunakan implementasi tambahan 2 dari C ++ berikut:

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

n bit akan ditetapkan jika x adalah 1 , dan dihapus jika x adalah 0 . Jika x memiliki arti berbeda, Anda mendapat sampah. x = !!x akan membuatnya menjadi 0 atau 1.

Untuk membuat ini independen dari perilaku add-on 2 add-on (di mana -1 memiliki semua bit yang ditetapkan, yang bertentangan dengan implementasi 1 add-on atau tanda / nilai C ++), gunakan negasi yang tidak ditandatangani.

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

atau

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

Biasanya merupakan ide yang baik untuk menggunakan tipe yang tidak ditandai untuk manipulasi bit portabel.

Secara umum, itu juga merupakan ide yang baik untuk tidak menyalin / menempelkan kode secara keseluruhan, dan oleh karena itu banyak orang menggunakan macro preprocessor (misalnya, respons dari komunitas wiki di bawah ) atau semacam enkapsulasi.

3179
07 сент. Balas diberikan oleh Jeremy Ruten 07 Sep 2008-09-07 03:50 '08 pada jam 3:50 2008-09-07 03:50

Menggunakan pustaka C ++ standar: std::bitset<N> .

Atau Tingkatkan : boost::dynamic_bitset .

Tidak perlu memutar diri:

 #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 

Versi Boost memungkinkan Anda untuk mengatur ukuran bit ke bit dibandingkan dengan bit rate standar .

405
18 сент. Balas diberikan oleh Martin York 18 Sep 2008-09-18 03:34 '08 pada jam 3:34 2008-09-18 03:34

Pilihan lain adalah dengan menggunakan bidang bit:

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

mendefinisikan bidang 3-bit (pada kenyataannya, ini adalah tiga bidang satu-bit). Operasi bit sekarang menjadi sedikit (haha) lebih mudah:

Untuk mengatur atau menghapus sedikit:

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

Untuk beralih sedikit:

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

Periksa bit:

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

Ini hanya berfungsi dengan bitfield ukuran tetap. Jika tidak, Anda harus menggunakan metode bit-twist yang dijelaskan dalam pesan sebelumnya.

224
11 сент. Jawabannya diberikan oleh Ferruccio 11 September. 2008-09-11 03:56 '08 pada jam 3:56 2008-09-11 03:56

Saya menggunakan makro yang didefinisikan dalam file header untuk menangani bit yang diatur dan dihapus:

  #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 нояб. Jawabannya diberikan oleh Steve Karg 05 Nov. 2008-11-05 01:35 '08 pada 1:35 pagi 2008-11-05 01:35

Terkadang layak menggunakan enum untuk menunjukkan bit:

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

Kemudian gunakan namanya nanti. Itu untuk menulis

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

instal, bersihkan dan periksa. Dengan cara ini Anda menyembunyikan angka ajaib dari sisa kode Anda.

Selain itu, saya mendukung keputusan Jeremy.

106
09 сент. jawabannya diberikan dmckee 09 Sep. 2008-09-09 00:07 '08 pada 0:07 2008-09-09 00:07

Dari 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))) 

Baiklah, biarkan dia menganalisis hal-hal ...

Ekspresi umum yang Anda miliki masalah dalam semua kasus ini adalah "(1L << (posn))". Semua ini menciptakan topeng dengan satu bit dan itu akan bekerja dengan semua tipe integer. Argumen "posn" menunjukkan posisi di mana Anda menginginkan bit. Jika posn == 0, maka ungkapan ini akan dievaluasi sebagai:

  0000 0000 0000 0000 0000 0000 0000 0001 binary. 

Jika posn == 8, ia akan mengevaluasi

  0000 0000 0000 0000 0000 0001 0000 0000 binary. 

Dengan kata lain, itu hanya membuat bidang 0 dengan 1 di posisi yang ditentukan. Satu-satunya bagian yang sulit adalah di makro BitClr (), di mana kita perlu mengatur satu bit 0 bit di bidang 1. Ini dicapai dengan menambahkan satu ke ekspresi yang sama, yang dilambangkan oleh operator tilde (~).

Segera setelah mask dibuat, ia diterapkan ke argumen dengan cara yang sama seperti yang Anda harapkan, menggunakan bitwise dan ( atau (|) dan operator xor (^). Karena jenis topengnya panjang, makro akan berfungsi seperti halnya pada char, pendek, int, atau panjang.

Intinya adalah bahwa ini adalah solusi umum untuk seluruh kelas masalah. Tentu saja, adalah mungkin dan bahkan disarankan untuk menulis u>

Yakin? Berikut adalah beberapa kode uji - Saya menggunakan Watcom C dengan optimisasi penuh dan tanpa menggunakan _cdecl, sehingga pembongkaran yang dihasilkan akan sebersih mungkin:

---- [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 (dibongkar)] ---------------------------------------------- ---------

 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 сент. balasan yang diberikan oleh yogeesh pada 17 September . 2008-09-17 05:04 '08 pada 5:04 2008-09-17 05:04

Gunakan operator bitwise: > |

Untuk mengatur bit terakhir ke 000b :

 foo = foo | 001b 

Untuk memeriksa bit terakhir di foo :

 if ( foo  001b ) .... 

Untuk menghapus bit terakhir di foo :

 foo = foo  110b 

Untuk lebih jelasnya, saya menggunakan XXXb . Anda mungkin akan bekerja dengan tampilan HEX, tergantung pada struktur data di mana Anda mengemas bit.

31
07 сент. Jawaban diberikan oleh nsanders 07 Sep 2008-09-07 03:45 '08 pada jam 3:45 2008-09-07 03:45

Untuk seorang pemula, saya ingin menjelaskan sedikit lebih banyak contoh:

Contoh:

 value is 0x55; bitnum : 3rd. 

> Operator digunakan untuk memeriksa bit:

 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) 

Beralih atau balik:

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

| : atur bitnya

 0101 0101 | 0000 1000 ___________ 0101 1101 (set the third bit without affecting other bits) 
31
05 июня '12 в 17:18 2012-06-05 17:18 jawabannya diberikan oleh kapilddit 05 Juni '12 pada 17:18 2012-06-05 17:18

Berikut ini adalah makro aritmatika bit favorit saya, yang berfungsi untuk semua jenis bi>unsigned char dari unsigned char ke size_t (yang merupakan jenis terbesar yang harus efektif untuk operasi):

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

Untuk mengatur bit:

 BITOP(array, bit, |=); 

Untuk menghapus bit:

 BITOP(array, bit, > 

Untuk beralih sedikit:

 BITOP(array, bit, ^=); 

Untuk memeriksa bit:

 if (BITOP(array, bit,  ... 

dan lainnya

26
13 июля '10 в 9:53 2010-07-13 09:53 jawabannya diberikan oleh R .. 13 Juli '10 pada 9:53 2010-07-13 09:53

Karena ini diberi label "tertanam", saya berasumsi bahwa Anda menggunakan mikrokontroler. Semua saran di atas valid dan berfungsi (baca-modifikasi-tulis, gabungan, struct, dll.).

Namun, selama tantangan berbasis osiloskop, saya kagum menemukan bahwa metode ini memiliki overhead yang signifikan dalam siklus prosesor dibandingkan dengan menulis nilai >

Bagi mereka yang tidak terbiasa: Dalam contoh saya, mikro memiliki PORTn register umum, yang menampilkan pin output, jadi PORTn | = BIT_TO_SET mengarah ke baca-modifikasi-tulis ke register ini. Namun, register PORTnSET / PORTnCLEAR diatur ke "1" yang berarti "tolong buat bit ini 1" (SET) atau "tolong buat bit ini nol" (CLEAR) dan "0" berarti "tinggalkan satu output". Oleh karena itu, Anda mendapatkan dua port, tergantung pada apakah Anda menginstal atau menghapus bit (tidak selalu nyaman), tetapi bereaksi lebih cepat dan mengurangi kode yang dikumpulkan.

23
14 июня '12 в 18:23 2012-06-14 18:23 Jawaban diberikan oleh John U pada 14 Juni '12 pada 18:23 2012-06-14 18:23

Pendekatan yang diterapkan memiliki kelebihan lain di arena tertanam. Anda dapat mendefinisikan struktur yang secara >

 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; 

Anda perlu tahu urutan pengepakan bit: pada awalnya saya pikir ini adalah MSB, tetapi ini mungkin tergantung pada implementasi. Juga, periksa bagaimana bidang pawang dari penangan Anda melewati batas byte.

Kemudian Anda dapat membaca, menulis, menguji nilai-nilai individual, seperti sebelumnya.

22
06 нояб. jawabannya diberikan oleh Roddy pada 06 November. 2008-11-06 14:30 '08 pada 14:30 2008-11-06 14:30

Lebih umum untuk gambar bitmap dengan ukuran acak:

 #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 jawabannya diberikan tagihan 14 Juni '09 pada 0:27 2009-06-14 00:27

Periksa bit di tempat sewenang-wenang dalam variabel tipe sewenang-wenang:

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

Menggunakan contoh:

 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; } 

Catatan: Ini dirancang untuk menjadi cepat (mengingat fleksibilitasnya) dan tidak bercabang. Ini mengarah pada kode SPARC yang efisien saat mengkompilasi Sun Studio 8; Saya juga mengujinya menggunakan MSVC ++ 2008 pada amd64. Anda dapat membuat makro serupa untuk mengatur dan menghapus bit. Perbedaan utama dari solusi ini dibandingkan dengan banyak yang lain di sini adalah bahwa ia bekerja untuk setiap lokasi di hampir semua jenis variabel.

18
04 янв. Jawaban diberikan oleh John Zwinck pada 4 Januari 2009-01-04 02:44 '09 pada 2:44 2009-01-04 02:44

Jika Anda melakukan banyak bit, Anda bisa menggunakan topeng yang akan mempercepat semuanya. Fungsi-fungsi berikut ini sangat cepat dan masih fleksibel (mereka memungkinkan pelipatan bit dalam berbagai ukuran ukuran).

 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; } 

Catatan: untuk mengatur bit 'n' ke integer 16-bit, Anda melakukan hal berikut:

 TSetBit( n, > 

Terserah Anda untuk memastikan bahwa nomor bit berada dalam kisaran kartu bit yang Anda transmisikan. Perhatikan bahwa untuk prosesor endian kecil, yaitu byte, kata, kata, kata, dll. Menampilkan dengan benar satu sama lain dalam memori (alasan utama mengapa prosesor endian kecil lebih baik daripada prosesor dalam jumlah besar, oh, saya merasa bahwa perang berapi-api mulai pada ...).

14
17 сент. Jawabannya diberikan Tim Ring 2008-09-17 17:10 '08 pukul 17:10 2008-09-17 17:10

Program ini dimaksudkan untuk mengubah bit data apa pun dari 0 menjadi 1 atau dari 1 menjadi 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 февр. jawabannya diberikan oleh Gokul Naathan pada 28 Feb. 2012-02-28 22:27 '12 pada 10:27 2012-02-28 22:27

Gunakan ini:

 int ToggleNthBit ( unsigned char n, int num ) { if(num  (1 << n)) num  ~(1 << n); else num |= (1 << n); return num; } 
11
12 апр. Jawab thangavel 12 Apr 2009-04-12 02:05 '09 pada pukul 02:05 2009-04-12 02:05

bitset respons bitset :

 #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 jawabannya diberikan oleh kendotwill 08 Mei '14 di 7:33 2014-05-08 07:33

Jika Anda ingin melakukan operasi ini dengan pemrograman C di kernel Linux, saya sarankan menggunakan API kernel Linux standar.

Lihat 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 

Catatan Di sini seluruh operasi dilakukan dalam satu >atom, bahkan pada komputer SMP dan berguna untuk memastikan konsistensi antara prosesor.

10
27 мая '16 в 19:41 2016-05-27 19:41 Jawaban diberikan oleh Jeegar Patel 27 Mei '16 pada 19:41 2016-05-27 19:41

Visual C 2010 dan mungkin banyak kompiler lain memiliki dukungan >

 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); } 

Jadi, untuk pertanyaan Anda IsGph [i] = 1 atau IsGph [i] = 0, sederhanakan pengaturan dan pembersihan bools.

Temukan karakter yang tidak patut dicetak ...

 // 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; } } 

Harap perhatikan bahwa kode ini tidak istimewa. Ini menangani bit secara keseluruhan, yang secara teknis. Bi>

Saya pernah menggunakan pendekatan ini untuk mencari catatan kredit duplikat, di mana number_name adalah kunci ISAM, menggunakan nomor kredit 6 digit sebagai indeks dalam bit-array. Segera dan segera, setelah 8 bulan, saya membuktikan bahwa sistem mainframe dari mana kami memperoleh data sebenarnya salah. Kesederhanaan bit-array membuat kepercayaan pada kebenarannya sangat tinggi - misalnya, di bawah pendekatan pencarian.

9
30 дек. Jawabannya diberikan oleh user1899861 30 Des. 2012-12-30 05:31 '12 pada 5:31 AM 2012-12-30 05:31

Gunakan salah satu operator seperti yang didefinisikan di sini .

Untuk mengatur bit, gunakan int x = x | 0x?; int x = x | 0x?; dimana ? - Ini adalah posisi bit dalam bentuk biner.

6
30 апр. Balas ke Jason 30 Apr 2012-04-30 09:48 '12 pada 9:48 2012-04-30 09:48

Berikut beberapa makro yang saya gunakan:

 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 февр. jawabannya diberikan oleh sam msft 07 Feb. 2015-02-07 02:11 '15 jam 2:11 pagi 2015-02-07 02:11

Bagaimana Anda mengatur, menghapus, dan beralih satu bit?

Untuk mengatasi masalah dengan kesalahan pengkodean yang umum saat mencoba membentuk topeng:
1 tidak selalu cukup lebar

Masalah apa yang muncul ketika number lebih luas dari 1 ?
x mungkin terlalu besar untuk bergeser 1 << x , menghasilkan perilaku tidak terdefinisi (UB). Bahkan jika x tidak terlalu besar, ~ mungkin tidak menyerahkan bit yang cukup signifikan.

 // 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 

Asuransikan 1 cukup luas:

Kode dapat digunakan 1ull atau pedantically (uintmax_t)1 dan mengoptimalkan kompiler.

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

Atau casting - itu membuat kesalahan pengkodean / review / pemeliharaan dengan tetap menjaga akurasi dan relevansi.

 number |= (type_of_number)1 << x; 

Atau dengan lembut maju 1 , memaksa operasi matematika yang lebih kecil dari tipe number .

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

Seperti kebanyakan manipulasi bit, yang terbaik adalah bekerja dengan tipe yang tidak ditandai, bukan yang ditandatangani.

4
27 сент. jawabannya diberikan chux 27 Sep 2017-09-27 21:18 '17 pada 21:18 2017-09-27 21:18

Versi template C ++ 11 (ditempatkan di header):

 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 февр. Jawaban diberikan oleh Joakim L. Christiansen pada 10 Feb. 2018-02-10 23:07 '18 pada 23:07 2018-02-10 23:07

Variabel yang Digunakan

 int value, pos; 

nilai - Data
pos - posisi bit yang ingin kita atur, hapus atau alihkan
Atur sedikit

 value = value | 1 << pos; 

Hapus sedikit

 value = value  ~(1 << pos); 

Beralih sedikit

 value = value ^ 1 << pos; 
3
11 июля '18 в 20:32 2018-07-11 20:32 jawabannya diberikan oleh Jeet Parikh pada 11 Juli '18 pukul 8:32 malam 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 февр. jawabannya diberikan oleh Sazzad Hissain Khan pada 21 Feb. 2018-02-21 15:35 '18 pukul 15.39 malam 2018-02-21 15:35

Untuk mengatur BitIdx -th bit ke Number on BitValue

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

Kuncinya di sini adalah untuk pertama-tama menghapus bit-bit -th tanpa syarat, menentukannya dengan 1. Versi ini terlihat agak lebih lambat daripada dengan bercabang ( if bit = 1 then setbit else clearbit ), tetapi adalah single-line.

-2
22 мая '17 в 11:24 2017-05-22 11:24 jawabannya diberikan pada Fr0sT pada 22 Mei 1717 di 11:24 2017-05-22 11:24

Coba salah satu dari fungsi C ini untuk mengubah n bit:

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

Atau

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

Atau

 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 jawabannya diberikan kepada Vincet pada 27 Mei '14 pada 14:46 2014-05-27 14:46