निम्नलिखित बिटकॉइन ऑपरेटरों के कुछ वास्तविक दुनिया उपयोग के मामले क्या हैं?
- तथा
- XOR
- नहीं
- या
- वाम / अधिकार शिफ्ट
निम्नलिखित बिटकॉइन ऑपरेटरों के कुछ वास्तविक दुनिया उपयोग के मामले क्या हैं?
जवाबों:
बिट फ़ील्ड (झंडे)
वे किसी चीज़ का प्रतिनिधित्व करने का सबसे कुशल तरीका हैं जिसका राज्य कई "हाँ या नहीं" गुणों से परिभाषित होता है। ACL एक अच्छा उदाहरण हैं; यदि आपके पास 4 असतत अनुमतियाँ हैं (पढ़ें, लिखें, निष्पादित करें, नीति बदलें), तो इसे कचरे के बजाय 1 बाइट में संग्रहीत करना बेहतर है। इन्हें अतिरिक्त सुविधा के लिए कई भाषाओं में गणना प्रकारों में मैप किया जा सकता है।
पोर्ट / सॉकेट पर संचार में
हमेशा चेकसम, समता, स्टॉप बिट्स, फ्लो कंट्रोल एल्गोरिदम शामिल होते हैं, और इसी तरह, जो आमतौर पर संख्यात्मक मूल्यों के विपरीत व्यक्तिगत बाइट्स के तर्क मूल्यों पर निर्भर करते हैं, क्योंकि माध्यम केवल एक बिट को प्रसारित करने में सक्षम हो सकता है। एक वक़्त।
संपीड़न, एन्क्रिप्शन
ये दोनों बिटवाइज़ एल्गोरिदम पर बहुत अधिक निर्भर हैं। को देखो Deflate एक उदाहरण के लिए एल्गोरिथ्म - सब कुछ बिट्स में है, तो बाइट्स नहीं।
परिमित राज्य मशीनें
मैं मुख्य रूप से हार्डवेयर के कुछ टुकड़े में एम्बेडेड प्रकार की बात कर रहा हूं, हालांकि वे सॉफ्टवेयर में भी पाए जा सकते हैं। ये प्रकृति में मिश्रित कर रहे हैं - वे सचमुच हो रही हो सकता है "संकलित" नीचे लॉजिक गेट का एक समूह के लिए, ताकि वे के रूप में व्यक्त किया जा सकता है AND
, OR
, NOT
, आदि
ग्राफ़िक्स
प्रोग्रामिंग प्रोग्रामिंग में इन ऑपरेटरों द्वारा उपयोग किए जाने वाले प्रत्येक क्षेत्र में आने के लिए यहाँ मुश्किल से ही पर्याप्त जगह है। XOR
(या ^
) यहां विशेष रूप से दिलचस्प है क्योंकि एक ही इनपुट को दूसरी बार लागू करने से पहली बार पूर्ववत हो जाएगी। पुराने GUIs ने चयन पर प्रकाश डाला और अन्य ओवरले के लिए इस पर भरोसा किया, ताकि महंगा रेड की जरूरत को खत्म किया जा सके। वे अभी भी धीमे ग्राफिक्स प्रोटोकॉल (यानी दूरस्थ डेस्कटॉप) में उपयोगी हैं।
वे सिर्फ पहले कुछ उदाहरण थे जिनके साथ मैं आया था - यह शायद ही एक विस्तृत सूची है।
क्या यह अजीब है?
(value & 0x1) > 0
क्या यह दो (यहां तक) से विभाज्य है?
(value & 0x1) == 0
यहां कुछ सामान्य मुहावरों को अलग-अलग बिट्स के रूप में संग्रहीत झंडे के साथ व्यवहार किया गया है।
enum CDRIndicators {
Local = 1 << 0,
External = 1 << 1,
CallerIDMissing = 1 << 2,
Chargeable = 1 << 3
};
unsigned int flags = 0;
चार्ट का ध्वज सेट करें:
flags |= Chargeable;
स्पष्ट कॉलरमिसिंग ध्वज:
flags &= ~CallerIDMissing;
परीक्षण करें कि क्या CallerIDMissing और Chargeable सेट हैं:
if((flags & (CallerIDMissing | Chargeable )) == (CallerIDMissing | Chargeable)) {
}
मैंने CMS के लिए सुरक्षा मॉडल लागू करने में बिटवाइज़ ऑपरेशंस का उपयोग किया है। इसमें ऐसे पृष्ठ थे, जिन्हें उपयुक्त समूहों में होने पर उपयोगकर्ताओं द्वारा एक्सेस किया जा सकता है। एक उपयोगकर्ता कई समूहों में हो सकता है, इसलिए हमें यह जांचने की आवश्यकता है कि क्या उपयोगकर्ता समूहों और पृष्ठों के समूहों के बीच एक चौराहा था। इसलिए हमने प्रत्येक समूह को एक अद्वितीय शक्ति -२ पहचानकर्ता, जैसे:
Group A = 1 --> 00000001
Group B = 2 --> 00000010
Group C = 3 --> 00000100
हम या ये मान एक साथ हैं, और पृष्ठ के साथ मूल्य (एक एकल int के रूप में) संग्रहीत करते हैं। उदाहरण के लिए, यदि कोई पृष्ठ A & B द्वारा एक्सेस किया जा सकता है, तो हम पेज एक्सेस कंट्रोल के रूप में मान 3 (जो बाइनरी में 00000011 है) को स्टोर करते हैं। उसी तरह, हम एक उपयोगकर्ता के साथ ओर्ड समूह के पहचानकर्ताओं के मान को दर्शाते हैं कि वे किस समूह में हैं।
इसलिए यह जांचने के लिए कि क्या कोई दिया गया उपयोगकर्ता किसी दिए गए पृष्ठ तक पहुंच सकता है, आपको बस एक साथ मानों की जरूरत है और यह जांचने के लिए कि क्या मूल्य शून्य नहीं है। यह बहुत तेज़ है क्योंकि यह चेक एकल निर्देश, कोई लूपिंग, कोई डेटाबेस राउंड-ट्रिप में लागू नहीं किया गया है।
निम्न स्तर की प्रोग्रामिंग एक अच्छा उदाहरण है। उदाहरण के लिए, हार्डवेयर के कुछ टुकड़े बनाने के लिए आपको मेमोरी-मैप्ड रजिस्टर में एक विशिष्ट बिट लिखने की आवश्यकता हो सकती है, जो आप इसे चाहते हैं:
volatile uint32_t *register = (volatile uint32_t *)0x87000000;
uint32_t value;
uint32_t set_bit = 0x00010000;
uint32_t clear_bit = 0x00001000;
value = *register; // get current value from the register
value = value & ~clear_bit; // clear a bit
value = value | set_bit; // set a bit
*register = value; // write it back to the register
इसके अलावा, htonl()
और htons()
उन ऑपरेटरों &
और |
ऑपरेटरों का उपयोग करके कार्यान्वित किया जाता है (जिन मशीनों का एंडियननेस (बाइट ऑर्डर) नेटवर्क ऑर्डर से मेल नहीं खाता):
#define htons(a) ((((a) & 0xff00) >> 8) | \
(((a) & 0x00ff) << 8))
#define htonl(a) ((((a) & 0xff000000) >> 24) | \
(((a) & 0x00ff0000) >> 8) | \
(((a) & 0x0000ff00) << 8) | \
(((a) & 0x000000ff) << 24))
htons()
और htonl()
एक स्वैप करने के लिए POSIX कार्य हैं short
या एक long
मेजबान (से h
नेटवर्क (करने के लिए) endianness n
) बाइट क्रम।
htonl()
एक 32-बिट के लिए int
मूल्य? long
कई भाषाओं में 64-बिट का मतलब है।
मैं उन्हें उदाहरण के लिए, पैक किए गए रंगीन रंगों से आरजीबी (ए) मान प्राप्त करने के लिए उपयोग करता हूं।
(a & b) >> c
तुलना में 5 गुना अधिक तेज है a % d / e
। क्रमशः, 1 बिलियन पुनरावृत्तियों के लिए 6.7 और 35.2s।
%
मापांक ऑपरेटर नहीं है, यह रेमिनेडर ऑपरेटर है। वे सकारात्मक मूल्यों के बराबर हैं, लेकिन नकारात्मक लोगों के साथ भिन्न हैं। यदि आप उपयुक्त प्रतिबंध प्रदान करते हैं ( उदाहरण uint
के int
लिए इसके बजाय ) तो दो उदाहरणों की गति समान होनी चाहिए।
जब मेरे पास बूलियन झंडे का एक गुच्छा होता है, तो मैं उन सभी को एक इंट में संग्रहीत करना पसंद करता हूं।
मैं उन्हें बिटवाइज़-एंड का उपयोग करके बाहर निकालता हूं। उदाहरण के लिए:
int flags;
if (flags & 0x10) {
// Turn this feature on.
}
if (flags & 0x08) {
// Turn a second feature on.
}
आदि।
if (flags.feature_one_is_one) { // turn on feature }
। यह एएनएसआई सी मानक में है, इसलिए पोर्टेबिलिटी एक मुद्दा नहीं होना चाहिए।
& = और:
विशिष्ट बिट्स को मास्क करें।
आप विशिष्ट बिट्स को परिभाषित कर रहे हैं जिन्हें प्रदर्शित किया जाना चाहिए या प्रदर्शित नहीं किया जाना चाहिए। 0x0 और x बाइट में सभी बिट्स को साफ़ कर देगा, जबकि 0xFF x को नहीं बदलेगा। 0x0F निचले निबल में बिट्स प्रदर्शित करेगा।
रूपांतरण:
कम चर वाले बिट चर को पहचानने के लिए बिट्स को समायोजित करना आवश्यक है क्योंकि एक इंट में -1 0xFFFFFFFF है जबकि एक लंबे समय में -1 0xFFFFFFFFFFFFFF है। पहचान को संरक्षित करने के लिए आप रूपांतरण के बाद एक मुखौटा लागू करते हैं।
| = या
बिट सेट करें। यदि वे पहले से सेट हैं, तो बिट्स को अनिश्चित रूप से सेट किया जाएगा। कई डेटास्ट्रक्चर (बिटफ़ील्ड्स) में IS_HSET = 0, IS_VSET = 1 जैसे झंडे होते हैं जिन्हें अनिश्चित रूप से सेट किया जा सकता है। झंडे सेट करने के लिए, आप IS_HSET लागू करें | IS_VSET (C और असेंबली में यह पढ़ना बहुत सुविधाजनक है)
^ = XOR
बिट्स खोजें जो समान या अलग हैं।
~ = नहीं
बिट्स फ्लिप।
यह दिखाया जा सकता है कि इन ऑपरेशनों द्वारा सभी संभावित स्थानीय बिट संचालन को लागू किया जा सकता है। इसलिए यदि आप चाहें, तो आप केवल बिट संचालन द्वारा एक ADD निर्देश लागू कर सकते हैं।
कुछ अद्भुत हैक:
http://www.ugcs.caltech.edu/~wnoise/base2.html
http://www.jjj.de/bitwizardry/bitwizardrypage.html
= ~
, नहीं |=
, जो OR है।
& = AND
- मैं सभी बिट्स क्यों साफ़ करना चाहूंगा, क्यों मैं बाइट का अनमॉडिफाइड संस्करण प्राप्त करना चाहता हूं, और निचले नीबूं के साथ मैं क्या करूं?
xor
अपने आप से है। मैं उन कुछ कारणों के बारे में सोच सकता हूं जिन्हें आप कम टट्टी निकालना चाहते हैं। खासतौर पर अगर वह निचला कुतरना डेटा संरचना का हिस्सा है और आप इसे मास्क के रूप में या OR
किसी अन्य संरचना के साथ उपयोग करना चाहते हैं ।
एन्क्रिप्शन सभी बिटवाइज़ ऑपरेशंस हैं।
आप उन्हें हैश डेटा के लिए एक त्वरित और गंदे तरीके के रूप में उपयोग कर सकते हैं।
int a = 1230123;
int b = 1234555;
int c = 5865683;
int hash = a ^ b ^ c;
यह बाइट प्रारूप में बिटमैप छवि से रंगों को पढ़ने के लिए एक उदाहरण है
byte imagePixel = 0xCCDDEE; /* Image in RRGGBB format R=Red, G=Green, B=Blue */
//To only have red
byte redColour = imagePixel & 0xFF0000; /*Bitmasking with AND operator */
//Now, we only want red colour
redColour = (redColour >> 24) & 0xFF; /* This now returns a red colour between 0x00 and 0xFF.
मुझे उम्मीद है कि यह छोटे उदाहरण मदद करते हैं ...।
आज की आधुनिक भाषा की अमूर्त दुनिया में, बहुत अधिक नहीं। फ़ाइल IO एक आसान है जो मन में आता है, हालांकि यह कि पहले से ही लागू कुछ पर बिटवाइज़ ऑपरेशन का उपयोग कर रहा है और कुछ ऐसे कार्यों को लागू नहीं कर रहा है जो बुद्धिमान संचालन का उपयोग करता है। फिर भी, एक आसान उदाहरण के रूप में, यह कोड किसी फ़ाइल पर रीड-ओनली विशेषता को हटाने का प्रदर्शन करता है (ताकि इसका उपयोग नए FileStream को निर्दिष्ट करते हुए FileMode.Create के साथ c # में किया जा सके:
//Hidden files posses some extra attibutes that make the FileStream throw an exception
//even with FileMode.Create (if exists -> overwrite) so delete it and don't worry about it!
if(File.Exists(targetName))
{
FileAttributes attributes = File.GetAttributes(targetName);
if ((attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
File.SetAttributes(targetName, attributes & (~FileAttributes.ReadOnly));
File.Delete(targetName);
}
जहाँ तक कस्टम कार्यान्वयन की बात है, यहाँ एक हालिया उदाहरण है: मैंने अपने वितरित एप्लिकेशन की एक स्थापना से दूसरे में सुरक्षित संदेश भेजने के लिए एक "संदेश केंद्र" बनाया। मूल रूप से, यह ईमेल के अनुरूप है, इनबॉक्स, आउटबॉक्स, सेंट आदि के साथ पूर्ण है, लेकिन इसमें रीड रसीदों के साथ डिलीवरी की गारंटी भी है, इसलिए "इनबॉक्स" और "भेजे" से परे अतिरिक्त सबफ़ोल्डर हैं। यह मेरे लिए सामान्य रूप से "इनबॉक्स में" या "भेजे गए फ़ोल्डर में" क्या है, को परिभाषित करने के लिए एक आवश्यकता थी। भेजे गए फ़ोल्डर में से, मुझे यह जानना होगा कि क्या पढ़ा है और क्या बिना पढ़े है। बिना पढ़े क्या है, मुझे यह जानना होगा कि क्या मिला और क्या नहीं। मैं इस जानकारी का उपयोग एक गतिशील बनाने के लिए करता हूं जहां क्लॉज एक स्थानीय डेटा स्रोत को फ़िल्टर करता है और उपयुक्त जानकारी प्रदर्शित करता है।
यहाँ बताया गया है कि एनम को एक साथ कैसे रखा जाता है:
public enum MemoView :int
{
InboundMemos = 1, // 0000 0001
InboundMemosForMyOrders = 3, // 0000 0011
SentMemosAll = 16, // 0001 0000
SentMemosNotReceived = 48, // 0011
SentMemosReceivedNotRead = 80, // 0101
SentMemosRead = 144, // 1001
Outbox = 272, //0001 0001 0000
OutBoxErrors = 784 //0011 0001 0000
}
क्या आप देखते हैं कि यह क्या करता है? "इनबॉक्स" enum मान के साथ Bying (&), InboundMemos, मुझे पता है कि InboundMemosForMyOrders इनबॉक्स में है।
यहां उस विधि का एक उबला हुआ संस्करण है जो वर्तमान में चयनित फ़ोल्डर के लिए दृश्य को परिभाषित करने वाले फ़िल्टर का निर्माण और रिटर्न करता है:
private string GetFilterForView(MemoView view, DefaultableBoolean readOnly)
{
string filter = string.Empty;
if((view & MemoView.InboundMemos) == MemoView.InboundMemos)
{
filter = "<inbox filter conditions>";
if((view & MemoView.InboundMemosForMyOrders) == MemoView.InboundMemosForMyOrders)
{
filter += "<my memo filter conditions>";
}
}
else if((view & MemoView.SentMemosAll) == MemoView.SentMemosAll)
{
//all sent items have originating system = to local
filter = "<memos leaving current system>";
if((view & MemoView.Outbox) == MemoView.Outbox)
{
...
}
else
{
//sent sub folders
filter += "<all sent items>";
if((view & MemoView.SentMemosNotReceived) == MemoView.SentMemosNotReceived)
{
if((view & MemoView.SentMemosReceivedNotRead) == MemoView.SentMemosReceivedNotRead)
{
filter += "<not received and not read conditions>";
}
else
filter += "<received and not read conditions>";
}
}
}
return filter;
}
अत्यंत सरल, लेकिन अमूर्त के स्तर पर एक साफ-सुथरा कार्यान्वयन जिसे आम तौर पर बिटवाइज़ संचालन की आवश्यकता नहीं होती है।
Base64 एन्कोडिंग एक उदाहरण है। बेस 64 एनकोडिंग का उपयोग बाइनरी डेटा को ईमेल सिस्टम (और अन्य उद्देश्यों) पर भेजने के लिए एक मुद्रण योग्य पात्रों के रूप में दर्शाने के लिए किया जाता है। Base64 एन्कोडिंग 8 बिट बाइट्स की एक श्रृंखला को 6 बिट कैरेक्टर लुकअप इंडेक्स में परिवर्तित करता है। बेस 64 एनकोडिंग और डिकोडिंग के लिए आवश्यक बिट ऑपरेशंस को लागू करने के लिए बिट ऑपरेशंस, शिफ्टिंग, एंडिंग, ऑरिंग, नोटिंग बहुत उपयोगी हैं।
यह कोर्स अनगिनत उदाहरणों में से केवल 1 है।
मुझे आश्चर्य है कि किसी ने भी इंटरनेट युग के लिए स्पष्ट जवाब नहीं उठाया। सबनेट के लिए मान्य नेटवर्क पते की गणना।
आमतौर पर बिटवाइज़ ऑपरेशन्स गुणा / भाग करने की तुलना में तेज़ होते हैं। इसलिए अगर आपको एक चर x को 9 से गुणा करने की आवश्यकता है, तो आप वह करेंगे x<<3 + x
जो कुछ चक्रों से तेज होगा x*9
। यदि यह कोड एक ISR के अंदर है, तो आप प्रतिक्रिया समय पर बचत करेंगे।
इसी तरह यदि आप एक सारणी का उपयोग एक गोलाकार कतार के रूप में करना चाहते हैं, तो बिट वार ऑपरेशन के साथ चेक के चारों ओर रैप को संभालने के लिए यह तेज़ (और अधिक सुरुचिपूर्ण) होगा। (आपकी सरणी का आकार 2 की शक्ति होना चाहिए)। जैसे: यदि आप सम्मिलित / हटाना चाहते हैं, तो आप tail = ((tail & MASK) + 1)
इसके बजाय उपयोग कर सकते हैं tail = ((tail +1) < size) ? tail+1 : 0
।
यदि आप एक त्रुटि ध्वज को एक साथ कई त्रुटि कोड रखना चाहते हैं, तो प्रत्येक बिट एक अलग मान रख सकता है। आप चेक के रूप में प्रत्येक व्यक्तिगत त्रुटि कोड के साथ कर सकते हैं। यह यूनिक्स त्रुटि कोड में उपयोग किया जाता है।
इसके अलावा एक एन-बिट बिटमैप वास्तव में शांत और कॉम्पैक्ट डेटा संरचना हो सकता है। यदि आप आकार n का संसाधन पूल आवंटित करना चाहते हैं, तो हम वर्तमान स्थिति का प्रतिनिधित्व करने के लिए n-बिट का उपयोग कर सकते हैं।
किसी को भी निश्चित बिंदु गणित का उल्लेख नहीं लगता है।
(हाँ, मैं बूढ़ा हूँ, ठीक है?)
क्या एक संख्या x
2 की शक्ति है? (एल्गोरिदम में उदाहरण के लिए उपयोगी जहां एक काउंटर बढ़ा हुआ है, और एक कार्रवाई केवल लघुगणकीय संख्या ली जानी है)
(x & (x - 1)) == 0
पूर्णांक का उच्चतम बिट कौन सा है x
? (उदाहरण के लिए इसका उपयोग 2 की न्यूनतम शक्ति को खोजने के लिए किया जा सकता है जो इससे बड़ा है x
)
x |= (x >> 1);
x |= (x >> 2);
x |= (x >> 4);
x |= (x >> 8);
x |= (x >> 16);
return x - (x >>> 1); // ">>>" is unsigned right shift
1
पूर्णांक का सबसे कम बिट कौन सा है x
? (2 से विभाज्य बार खोजने में मदद करता है)
x & -x
x & -x
।
बिटवाइज़ ऑपरेटर्स लूपिंग सरणियों के लिए उपयोगी हैं, जिनकी लंबाई 2 की शक्ति है। जैसा कि कई लोगों ने उल्लेख किया है, बिटवाइज़ ऑपरेटर बेहद उपयोगी होते हैं और इनका उपयोग झंडे , ग्राफिक्स , नेटवर्किंग , एन्क्रिप्शन में किया जाता है । इतना ही नहीं, लेकिन वे बहुत तेज हैं। मेरा व्यक्तिगत पसंदीदा उपयोग सशर्त बिना किसी सरणी को लूप करना है । मान लें कि आपके पास एक शून्य-सूचकांक आधारित सरणी है (उदाहरण के लिए पहला तत्व का सूचकांक 0 है) और आपको इसे अनिश्चित काल तक लूप करने की आवश्यकता है। अनिश्चित काल तक मेरा मतलब है कि पहले तत्व से आखिरी तक जाना और पहले पर लौटना। इसे लागू करने का एक तरीका है:
int[] arr = new int[8];
int i = 0;
while (true) {
print(arr[i]);
i = i + 1;
if (i >= arr.length)
i = 0;
}
यह सबसे सरल तरीका है, यदि आप यदि कथन से बचना चाहते हैं, तो आप मापांक दृष्टिकोण का उपयोग कर सकते हैं :
int[] arr = new int[8];
int i = 0;
while (true) {
print(arr[i]);
i = i + 1;
i = i % arr.length;
}
इन दोनों विधियों के नीचे का पक्ष यह है कि मापांक ऑपरेटर महंगा है, क्योंकि यह पूर्णांक विभाजन के बाद शेष के लिए दिखता है। और पहली विधि एक चलाता है, तो प्रत्येक यात्रा पर बयान। बिटवाइज़ ऑपरेटर के साथ हालांकि यदि आपकी सरणी की लंबाई 2 की शक्ति है, तो आप आसानी से (बिटवाइज़) और ऑपरेटर 0 .. length - 1
का उपयोग करके एक अनुक्रम उत्पन्न कर सकते हैं । तो यह जानकर ऊपर से कोड बन जाता है&
i & length
int[] arr = new int[8];
int i = 0;
while (true){
print(arr[i]);
i = i + 1;
i = i & (arr.length - 1);
}
यहाँ दिया गया है कि यह कैसे काम करता है। में द्विआधारी प्रारूप हर संख्या है कि 2 की शक्ति 1 से घटाया है केवल लोगों के साथ व्यक्त की है। उदाहरण के लिए 3 बाइनरी में है 11
, 7 है 111
, 15 है 1111
और इसी तरह, आपको विचार मिलता है। अब, यदि आप &
किसी भी संख्या के खिलाफ किसी भी संख्या को द्विआधारी में शामिल करते हैं तो क्या होता है ? मान लें कि हम ऐसा करते हैं:
num & 7;
यदि num
7 से छोटा या बराबर है तो परिणाम होगा num
क्योंकि &
1 के साथ प्रत्येक बिट स्वयं है। यदि num
7 से बड़ा है, तो &
ऑपरेशन के दौरान कंप्यूटर 7 के अग्रणी शून्य पर विचार करेगा, जो निश्चित रूप से &
ऑपरेशन के बाद शून्य के रूप में रहेगा, केवल अनुगामी भाग रहेगा। जैसे 9 & 7
बाइनरी के मामले में यह दिखेगा
1001 & 0111
परिणाम 0001 होगा जो दशमलव में 1 है और सरणी में दूसरा तत्व है।
यह एक sql रिलेशनल मॉडल में भी उपयोगी हो सकता है, मान लें कि आपके पास निम्न तालिकाएँ हैं: BlogEntry, BlogCategory
परंपरागत रूप से आप एक BlogEntryCategory तालिका का उपयोग करके उन दोनों के बीच एक nn संबंध बना सकते हैं या जब इतने BlogCategory रिकॉर्ड नहीं होते हैं, तो आप BlogEntry में एक मान को कई BlogCategory रिकॉर्ड से लिंक करने के लिए उपयोग कर सकते हैं, जैसे कि आप ध्वजांकित एनमों के साथ करेंगे, अधिकांश RDBMS में भी हैं उस 'ध्वजांकित' कॉलम पर चयन करने के लिए एक बहुत तेज़ ऑपरेटर ...
जब आप केवल एक माइक्रोकंट्रोलर के आउटपुट के कुछ बिट्स को बदलना चाहते हैं, लेकिन एक बाइट को लिखने के लिए रजिस्टर, आप कुछ इस तरह से करते हैं (स्यूडोकोड):
char newOut = OutRegister & 0b00011111 //clear 3 msb's
newOut = newOut | 0b10100000 //write '101' to the 3 msb's
OutRegister = newOut //Update Outputs
बेशक, कई माइक्रोकंट्रोलर आपको व्यक्तिगत रूप से प्रत्येक बिट को बदलने की अनुमति देते हैं ...
यदि आप कभी भी अपने संख्या मॉड (%) 2 की एक निश्चित शक्ति की गणना करना चाहते हैं, तो आप उपयोग कर सकते हैं yourNumber & 2^N-1
, जो इस मामले में समान है yourNumber % 2^N
।
number % 16 = number & 15;
number % 128 = number & 127;
यह संभवत: केवल एक बहुत बड़े लाभांश के साथ मापांक ऑपरेशन के विकल्प के रूप में उपयोगी है जो 2 ^ N है ... लेकिन फिर भी मापांक ऑपरेशन पर इसकी गति को बढ़ावा देना .NET 2.0 पर मेरे परीक्षण में नगण्य है। मुझे संदेह है कि आधुनिक कंपाइलर पहले से ही इस तरह के अनुकूलन करते हैं। क्या किसी को भी इस बारे में अधिक पता है?
%
कि रेमिनेडर ऑपरेशन है, वे नकारात्मक तरीके से अलग व्यवहार करते हैं। हालाँकि, यदि आप पास uint
हो जाते हैं %
, तो C # संकलक वास्तव में बिटवाइज़ का उपयोग करके मशीन कोड का उत्पादन करेगा और जब दूसरा तर्क दो की पूर्व-ज्ञात शक्ति है।
यहाँ मेरे सवाल में एक वास्तविक दुनिया का उपयोग है -
केवल पहले WM_KEYDOWN अधिसूचना का जवाब दें?
जब विंडोज़ सी एपी बिट 30 में WM_KEYDOWN संदेश का उपभोग करते हैं, तो पिछले प्रमुख स्थिति को निर्दिष्ट करता है। मान 1 है यदि संदेश भेजने से पहले कुंजी नीचे है, या यदि कुंजी ऊपर है तो यह शून्य है
वे ज्यादातर बिटवाइज़ ऑपरेशन (आश्चर्य) के लिए उपयोग किए जाते हैं। यहाँ PHP कोडबेस में पाए जाने वाले कुछ वास्तविक दुनिया उदाहरण हैं।
अक्षरों को सांकेतिक अक्षरों में बदलना:
if (s <= 0 && (c & ~MBFL_WCSPLANE_MASK) == MBFL_WCSPLANE_KOI8R) {
डेटा संरचनाएं:
ar_flags = other->ar_flags & ~SPL_ARRAY_INT_MASK;
डेटाबेस ड्राइवर:
dbh->transaction_flags &= ~(PDO_TRANS_ACCESS_MODE^PDO_TRANS_READONLY);
संकलक कार्यान्वयन:
opline->extended_value = (opline->extended_value & ~ZEND_FETCH_CLASS_MASK) | ZEND_FETCH_CLASS_INTERFACE;
जब भी मैंने पहली बार C प्रोग्रामिंग शुरू की, मुझे सत्य सारणी और वह सब समझ में आया, लेकिन यह सब वास्तव में इसका उपयोग करने के लिए क्लिक नहीं करता था जब तक कि मैं इस लेख को नहीं पढ़ता http://www.gamedev.net/reference/articles/article1563.asp (जो वास्तविक जीवन के उदाहरण देता है)
x == 1
और y == 2
, तो x || y
1 का मूल्यांकन करता है, और x | y
0. का मूल्यांकन करता है और न ही मैं देखता हूं कि किसी भी तरह x^true
से बेहतर क्यों है !x
। यह अधिक टाइपिंग, कम मुहावरेदार है, और अगर x
ऐसा नहीं होता है तो bool
यह अविश्वसनीय है।
x^true
से बेहतर है !x
है some->complicated().member->lookup ^= true;
एकल ऑपरेटरों की कोई यौगिक-असाइनमेंट संस्करण हैं।
मुझे नहीं लगता कि यह बिटवाइज़ के रूप में गिना जाता है, लेकिन रूबी का ऐरे सामान्य पूर्णांक बिटवाइज़ ऑपरेटरों के माध्यम से सेट संचालन को परिभाषित करता है। तो [1,2,4] & [1,2,3] # => [1,2]
। इसी के लिए a ^ b #=> set difference
और a | b #=> union
।
हनोई रैखिक समाधान का टॉवर समस्या को हल करने के लिए बिटवाइज़ संचालन का उपयोग करता है।
public static void linear(char start, char temp, char end, int discs)
{
int from,to;
for (int i = 1; i < (1 << discs); i++) {
from = (i & i-1) % 3;
to = ((i | i-1) + 1) % 3;
System.out.println(from+" => "+to);
}
}