दिलचस्प पोस्ट
क्यों है धीमी गति से? प्राथमिक कुंजी से कई संस्थाएं प्राप्त करने का सबसे कारगर तरीका है? मुख्य ग्वि को अपडेट करने के लिए जावा स्विंगवर्कर धागा वर्डप्रेस में मौजूदा पृष्ठ का नाम कैसे प्राप्त करें? फोनगैप – लैंडस्केप अभिविन्यास को मजबूर करना mysql लेनदेन – किसी भी अपवाद पर वापस रोल एंड्रॉइड एप्लीकेशन में कैश्ड को साफ़ करें कैसे स्वचालित रूप से एन "अलग" रंग उत्पन्न करने के लिए? यह कैसे देख सकता है कि क्या रिमोट फाइल PHP का प्रयोग कर रही है? मान्यएन्टीफ़ॉर्गरीटीन उद्देश्य, स्पष्टीकरण और उदाहरण अलग आइटम लेआउट के साथ ListView के लिए ViewHolders बनाना 'माइक्रोसॉफ्ट.एसीई। ओएलईडीबी .12.0' प्रदाता स्थानीय मशीन पर पंजीकृत नहीं है, जबकि एमएस एक्सेस के लिए डाटा निर्यात एंड्रॉइड स्पलैशस्क्रीन C ++ में फ्लोट के लिए गोल () क्या NOLOCK (SQL सर्वर संकेत) खराब अभ्यास है? क्यूटी लिंकर त्रुटि: "vtable के लिए अपरिभाषित संदर्भ"

आप एक बिट को कैसे सेट, साफ़ और टॉगल करते हैं?

सी / सी ++ में आप कैसे सेट, रिक्त और थोड़ा सा टॉगल करते हैं?

वेब के समाधान से एकत्रित समाधान "आप एक बिट को कैसे सेट, साफ़ और टॉगल करते हैं?"

थोड़ा सा सेट करना

बिट सेट करने के लिए bitwise या ऑपरेटर ( | ) का उपयोग करें

 number |= 1UL << x; 

यह बिट x सेट करेगा

यदि number unsigned long से अधिक व्यापक है, तो 1ULL उपयोग करें; 1UL << x पदोन्नति 1UL << x 1UL << x मूल्यांकन करने के बाद तब तक नहीं होता 1UL << x जहां यह यूबी के लिए long की चौड़ाई से अधिक स्थानांतरित होता है वही सभी उदाहरणों पर लागू होता है

थोड़ी सफाई

बिटवर्ड एंड ऑपरेटर ( & ) का उपयोग थोड़ा सा साफ़ करने के लिए करें।

 number &= ~(1UL << x); 

यह थोड़ा x साफ होगा आपको bitwise NOT ऑपरेटर ( ~ ) के साथ बिट स्ट्रिंग को पलटना चाहिए, और फिर

थोड़ा सा टॉगलिंग

XOR ऑपरेटर ( ^ ) का उपयोग थोड़ा सा टॉगल करने के लिए किया जा सकता है

 number ^= 1UL << x; 

यह बिट x टॉगल होगा

थोड़ी जांच

आपने इस के लिए नहीं पूछा था लेकिन मैं इसे जोड़ सकता हूं।

थोड़ा जांच करने के लिए, संख्या को दाईं ओर स्थानांतरित करें, फिर बिटवर्ड और यह:

 bit = (number >> x) & 1U; 

यह बिट x का मान चर bit में डाल देगा I

एक्स के लिए n वें बिट को बदलना

एनएपी को 1 या 0 सेट करना 2 के पूरक C ++ कार्यान्वयन पर निम्नलिखित के साथ प्राप्त किया जा सकता है:

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

बिट n सेट किया जाएगा यदि x 1 , और अगर x 0 है तो इसे मंजूरी यदि x में कोई अन्य मान है, तो आपको कचरा मिलता है। x = !!x इसे 0 या 1 में बुलियन कर देगा।

2 के पूरक प्रतिषेध व्यवहार से स्वतंत्र बनाने के लिए (जहां -1 के सभी बिट सेट हैं, 1 के पूरक या चिन्ह / परिमाण सी ++ कार्यान्वयन के विपरीत), अहस्ताक्षरित निषेध का उपयोग करें

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

या

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

पोर्टेबल बिट हेरफेर के लिए अहस्ताक्षरित प्रकार का उपयोग करना आम तौर पर एक अच्छा विचार है

मानक C ++ लाइब्रेरी का प्रयोग करना: std::bitset<N>

या बूस्ट संस्करण: boost::dynamic_bitset

अपने आप को रोल करने की कोई आवश्यकता नहीं है:

 #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 

बूस्ट संस्करण मानक लाइब्रेरी कंपाइल-टाइम आकार के बिट्ससेट की तुलना में रनटाइम आकार के बिट्ससेट की अनुमति देता है।

दूसरा विकल्प बिट फ़ील्ड का उपयोग करना है:

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

एक 3-बिट फील्ड को परिभाषित करता है (वास्तव में, यह तीन 1-बिट फ़्ल्ड्स है) बिट ऑपरेशन अब थोड़े (हाहा) सरल बन जाते हैं:

कुछ सेट या साफ़ करने के लिए:

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

थोड़ा टॉगल करने के लिए:

 mybits.a = !mybits.a; mybits.b = ~mybits.b; mybits.c ^= 1; /* all work */ 

थोड़ी जांच:

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

यह फिक्स्ड-आकार बिट फ़ील्ड के साथ ही काम करता है अन्यथा आपको पिछली पोस्ट में वर्णित बिट-ट्विडिंग तकनीक का सहारा लेना होगा।

मैं बिट सेट और साफ़ करने के लिए हेडर फ़ाइल में परिभाषित मैक्रोज का उपयोग करता हूं:

 /* a=target variable, b=bit number to act upon 0-n */ #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))) /* x=target variable, y=mask */ #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)) 

कभी-कभी बिट्स नाम देने के लिए एक enum का इस्तेमाल करना लायक है:

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

फिर बाद में नामों का उपयोग करें Ie लिखें

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

सेट, स्पष्ट और परीक्षण करने के लिए इस तरह से आप अपने बाकी कोड से जादू संख्या छिपाते हैं।

इसके अलावा मैं जेरेमी के समाधान का समर्थन करता हूं।

स्निप-सीज़िप के बिटॉप से। कैसे :

 /* ** Bit set, clear, and test operations ** ** public domain snippet by Bob Stout */ 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))) 

ठीक है, चलो चीजों का विश्लेषण …

उन सभी में सामान्य अभिव्यक्ति जिसमें आप के साथ समस्या होने लगता है "(1 एल << (posn))" यह सब एक एकल बिट के साथ एक मुखौटा बनाते हैं और जो किसी भी पूर्णांक प्रकार के साथ काम करेगा। "पॉज़्न" तर्क उस स्थिति को निर्दिष्ट करता है जहां आप बिट करना चाहते हैं। अगर posn == 0, तो यह अभिव्यक्ति इसका मूल्यांकन करेगा:

  0000 0000 0000 0000 0000 0000 0000 0001 binary. 

अगर posn == 8, यह मूल्यांकन करेगा

  0000 0000 0000 0000 0000 0001 0000 0000 binary. 

दूसरे शब्दों में, यह केवल 0 के क्षेत्र को 1 के साथ निर्दिष्ट स्थान पर बनाता है। केवल मुश्किल हिस्सा बीटक्लर () मैक्रो में है, जहां हमें 1 के क्षेत्र में एक 0 बिट सेट करना होगा। टिल्ड (~) ऑपरेटर द्वारा दर्शाए गए समान अभिव्यक्ति के 1 के पूरक के उपयोग से यह पूरा किया जाता है।

एक बार मुखौटा बनाया जाता है, तो यह तर्क के लिए लागू होता है जैसा कि आप सुझाव देते हैं, bitwise और (&), या (|), और xor (^) ऑपरेटरों के उपयोग के द्वारा। चूंकि मुखौटा प्रकार लंबे प्रकार से है, इसलिए मैक्रोज चारों के समान ही काम करेगा, लघु, इंट, या लंबे समय तक।

निचला रेखा यह है कि यह समस्याओं की एक पूरी कक्षा के लिए एक सामान्य समाधान है। यह निश्चित रूप से संभव है कि इन मैक्रोज़ के समतुल्य को दोबारा लिखना संभव है और जब भी आपको एक बार मुखर मुखौटा मूल्यों की ज़रूरत होती है, लेकिन यह क्यों? याद रखें, मैक्रो प्रतिस्थापन पूर्वप्रक्रमक में होता है और इसलिए उत्पन्न कोड इस तथ्य को प्रतिबिंबित करेगा कि मूल्यों को संकलक द्वारा स्थिर माना जाता है – यानी सामान्यीकृत मैक्रोज़ का उपयोग करने के लिए जितनी कुशल हैं, उतनी ही हर बार "पहिया को फिर से संशोधित करें" बिट हेरफेर करना

असंतुष्ट? यहाँ कुछ परीक्षण कोड है – मैंने पूर्ण अनुकूलन के साथ Watcom C का उपयोग किया है और बिना _cdecl का उपयोग किया है ताकि परिणामस्वरूप असंतुष्ट संभव के रूप में साफ हो जाएगा:

—- [टेस्ट.सी] —————————————– ———————–

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

—- [टेस्ट.ओयूटी (डिस्साइम्ड)] ————————————– ———

 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 

—- [फाइनिस] ——————————————- ———————-

शुरुआती के लिए मैं एक उदाहरण के साथ थोड़ी अधिक व्याख्या करना चाहूंगा:

उदाहरण:

 value is 0x55; bitnum : 3rd. 

द ऑपरेटर का इस्तेमाल थोड़ा जांच कर रहा है:

 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) 

टॉगल या फ्लिप करें:

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

| ऑपरेटर: बिट सेट

 0101 0101 | 0000 1000 ___________ 0101 1101 (set the third bit without affecting other bits) 

Bitwise ऑपरेटर्स का उपयोग करें: & |

000 बी में अंतिम बिट सेट करने के लिए:

 foo = foo | 001b 

Foo में पिछले बिट की जांच करने के लिए:

 if ( foo & 001b ) .... 

Foo में अंतिम बिट को साफ़ करने के लिए:

 foo = foo & 110b 

मैंने स्पष्टता के लिए XXXb का इस्तेमाल किया। आप संभवतः हेक्स प्रतिनिधित्व के साथ काम करेंगे, डेटा संरचना के आधार पर जिसमें आप बिट्स पैक कर रहे हैं।

यह मेरा पसंदीदा बिट अंकगणित मैक्रो है, जो किसी भी प्रकार के अहस्ताक्षरित पूर्णांक सरणी के लिए unsigned char ऊपर size_t तक काम करता है (जो सबसे बड़ा प्रकार है जिसके साथ काम करने के लिए कुशल होना चाहिए):

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

थोड़ा सेट करने के लिए:

 BITOP(array, bit, |=); 

थोड़ा साफ़ करने के लिए:

 BITOP(array, bit, &=~); 

थोड़ा टॉगल करने के लिए:

 BITOP(array, bit, ^=); 

थोड़ा परीक्षण करने के लिए:

 if (BITOP(array, bit, &)) ... 

आदि।

जैसा कि इसे "एम्बेडेड" टैग किया गया है, मैं मानूंगा कि आप एक माइक्रोकंट्रोलर का प्रयोग कर रहे हैं। उपर्युक्त सभी सुझाव मान्य और काम (पढ़ने-संशोधित-लेखन, यूनियन, स्ट्रैक्ट्स आदि) हैं।

हालांकि, ऑसिलोस्कोप-आधारित डिबगिंग के एक डटने के दौरान मुझे यह पता चला है कि इन तरीकों के पास सीपीयू चक्रों में काफी मार्जिन है, जो कि सीधे माइक्रो के पोर्टनसेटी / पोर्टनकेलर रजिस्टरों को लिखते हैं, जो वास्तविक फर्क पड़ता है जहां कड़े छोरों / उच्चतर हैं फ्रीक्वेंसी आईएसआर के टॉगलिंग पिंस

उन अपरिचित लोगों के लिए: मेरे उदाहरण में, सूक्ष्म में एक सामान्य पिन-स्टेट रजिस्टर रजिस्टर है जो आउटपुट पिंस को दर्शाता है, इसलिए PORTn | = BIT_TO_SET को उस रजिस्टर में पढ़ने-संशोधित-लिखने में परिणाम देता है। हालांकि, PORTNSET / PORTNCLEAR रजिस्टरों के लिए "1 बिट करें" (एसईटी) या "कृपया यह बिट शून्य करें" (CLEAR) और एक '0' का मतलब करने के लिए "अकेले पिन छोड़ दें" का मतलब करने के लिए एक '1' लेते हैं। इसलिए, आप दो बंदरगाहों के पते के साथ समाप्त होते हैं, भले ही आप बिट सेट या साफ़ कर रहे हों (हमेशा सुविधाजनक नहीं) लेकिन बहुत तेज़ प्रतिक्रिया और छोटे इकट्ठे कोड

बिटफ़िल्ल्ड दृष्टिकोण में एम्बेडेड क्षेत्र में अन्य फायदे हैं। आप एक स्ट्रेट को परिभाषित कर सकते हैं जो सीधे किसी विशेष हार्डवेयर रजिस्टर में बिट्स पर नक्शे को दर्शाता है।

 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; 

आपको बिट पैकिंग ऑर्डर के बारे में पता होना चाहिए – मुझे लगता है कि यह पहले MSB है, लेकिन यह कार्यान्वयन-निर्भर हो सकता है साथ ही, सत्यापित करें कि आपके कंपाइलर हैंडलर बाइट सीमाओं को कैसे पार करते हैं।

तब आप व्यक्तिगत मानों को पहले से पढ़ सकते हैं, लिख सकते हैं।

अधिक सामान्य, मनमाना आकार के बिटमैप के लिए:

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

मनमाना प्रकार के एक चर में एक मनमाना स्थान पर थोड़ा सा चेक करें:

 #define bit_test(x, y) ( ( ((const char*)&(x))[(y)>>3] & 0x80 >> ((y)&0x07)) >> (7-((y)&0x07) ) ) 

नमूना उपयोग:

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

नोट्स: यह तेजी से (इसके लचीलेपन को देखते हुए) और गैर-शाखाओं के लिए डिज़ाइन किया गया है। यह कुशल एसपीएआरसी मशीन कोड का परिणाम है जब सन स्टूडियो 8; मैंने यह भी एमएसवीसी ++ 2008 का उपयोग कर AMD64 पर परीक्षण किया है। बिट्स को सेट करने और साफ़ करने के लिए समान मैक्रोज बनाना संभव है। इस समाधान के मुख्य अंतर में कई अन्य लोगों की तुलना में यह है कि यह किसी भी स्थान के लिए बहुत अधिक किसी प्रकार के चर के लिए काम करता है।

यदि आप बहुत अधिक गतिशील हैं तो आप मुखौटे का उपयोग करना चाहेंगे जो पूरी तरह से तेज़ी से कर देगा। निम्नलिखित फ़ंक्शंस बहुत तेजी से और अभी भी लचीले हैं (वे किसी भी आकार के बिट मैप्स में थोड़ी चक्कर लगाते हैं)

 const unsigned char TQuickByteMask[8] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, }; /** Set bit in any sized bit mask. * * @return none * * @param bit - Bit number. * @param bitmap - Pointer to bitmap. */ 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. } /** Reset bit in any sized mask. * * @return None * * @param bit - Bit number. * @param bitmap - Pointer to bitmap. */ 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. } /** Toggle bit in any sized bit mask. * * @return none * * @param bit - Bit number. * @param bitmap - Pointer to bitmap. */ 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. } /** Checks specified bit. * * @return 1 if bit set else 0. * * @param bit - Bit number. * @param bitmap - Pointer to bitmap. */ 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; } /** Checks specified bit. * * @return 1 if bit reset else 0. * * @param bit - Bit number. * @param bitmap - Pointer to bitmap. */ short TIsBitReset( short bit, const unsigned char *bitmap) { return TIsBitSet( bit, bitmap) ^ 1; } /** Count number of bits set in a bitmap. * * @return Number of bits set. * * @param bitmap - Pointer to bitmap. * @param size - Bitmap size (in bits). * * @note Not very efficient in terms of execution speed. If you are doing * some computationally intense stuff you may need a more complex * implementation which would be faster (especially for big bitmaps). * See (http://graphics.stanford.edu/~seander/bithacks.html). */ 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; } 

ध्यान दें, बिट 'एन' को 16 बिट पूर्णांक में सेट करने के लिए आप निम्न करते हैं:

TSetBit (n, & my_int);

यह सुनिश्चित करने के लिए आपके ऊपर निर्भर है कि बिट संख्या बिट मैप की सीमा के भीतर है जिसे आप पास करते हैं ध्यान दें कि छोटे एंडियन प्रोसेसर के लिए कि बाइट्स, शब्द, पासवर्ड, कूटशब्द आदि, मैमोरी में एक-दूसरे के लिए सही तरीके से मैप करते हैं (मुख्य कारण यह है कि बड़े एंडियन प्रोसेसर की तुलना में बहुत कम एंडियन प्रोसेसर 'बेहतर' हैं, आह, मुझे लगता है कि एक ज्वाला युद्ध आ रहा है। ..)।

इसे इस्तेमाल करो:

 int ToggleNthBit ( unsigned char n, int num ) { if(num & (1 << n)) num &= ~(1 << n); else num |= (1 << n); return num; } 

यह प्रोग्राम 0 से 1 या 1 से 0 तक किसी भी डेटा बिट को परिवर्तित करना है:

 { unsigned int data = 0x000000F0; int bitpos = 4; int bitvalue = 1; unsigned int bit = data; bit = (bit>>bitpos)&0x00000001; int invbitvalue = 0x00000001&(~bitvalue); 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); } } } 

यदि आप लिनक्स कर्नेल में सी प्रोग्रामिंग के साथ यह सब ऑपरेशन करना चाहते हैं तो मैं लिनक्स कर्नेल के मानक एपीआईएस का उपयोग करने का सुझाव देता हूं।

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 

नोट: यहां एक ही चरण में पूरे ऑपरेशन होता है, इसलिए इन सभी को एसएमपी कंप्यूटर्स पर भी परमाणु होने की गारंटी दी जाती है और प्रोसेसर में एकजुट रखने के लिए उपयोगी हैं।

दृश्य सी 2010, और संभवत: कई अन्य कंपाइलर, में बिट ऑपरेशन के लिए सीधा समर्थन है। आश्चर्यजनक रूप से, यह काम करता है, यहां तक ​​कि आकार के () ऑपरेटर ठीक से काम करता है

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

तो, आपके प्रश्न के लिए, आईएसजीएफ [आई] = 1, या आईएसजीएफ [आई] = 0 सेट करना और बूल को साफ़ करना आसान है।

अनपेक्षित वर्ण ढूंढने के लिए …

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

ध्यान दें कि इस कोड के बारे में "विशेष" नहीं है। It treats a bit like an integer – which technically, it is. A 1 bit integer that can hold 2 values, and 2 values only.

I once used this approach to find duplicate loan records, where loan_number was the ISAM key, using the 6-digit loan number as an index into the bit array. Savagely fast, and after 8 months, proved that the mainframe system we were getting the data from was in fact malfunctioning. The simplicity of bit arrays makes confidence in their correctness very high – vs a searching approach for example.

Expanding on the bitset answer:

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

Use one of the operators as defined here .

To set a bit, used int x = x | 0x?; where ? is the bit position in binary form.

Here are some macros I use:

 SET_FLAG(Status, Flag) ((Status) |= (Flag)) CLEAR_FLAG(Status, Flag) ((Status) &= ~(Flag)) INVALID_FLAGS(ulFlags, ulAllowed) ((ulFlags) & ~(ulAllowed)) TEST_FLAGS(t,ulMask, ulBit) (((t)&(ulMask)) == (ulBit)) IS_FLAG_SET(t,ulMask) TEST_FLAGS(t,ulMask,ulMask) IS_FLAG_CLEAR(t,ulMask) TEST_FLAGS(t,ulMask,0) 

How do you set, clear, and toggle a single bit?

To address a common coding pitfall when attempting to form the mask:
1 is not always wide enough

What problems happen when number is a wider type than 1 ?
x may be too great for the shift 1 << x leading to undefined behavior (UB). Even if x is not too great, ~ may not flip enough most-significant-bits.

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

To insure 1 is wide enough:

Code could use 1ull or pedantically (uintmax_t)1 and let the compiler optimize.

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

Or cast – which makes for coding/review/maintenance issues keeping the cast correct and up-to-date.

 number |= (type_of_number)1 << x; 

Or gently promote the 1 by forcing a math operation that is as least as wide as the type of number .

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

As with most bit manipulations, best to work with unsigned types rather than signed ones

For setting BitIdx -th bit in Number to BitValue

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

The trick here is to first unconditionally clear the BitIdx -th bit by xor-ing it with 1. This version seems slightly slower than the one with branching ( if bit = 1 then setbit else clearbit ) but is a one-liner.

Try one of these functions in C language to change n bit

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

या

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

या

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