इस ट्यूटोरियल में, हम C # में बिटवाइज़ और बिट शिफ्ट ऑपरेटर्स के बारे में विस्तार से जानेंगे। C # 4 बिटवाइज़ और 2 बिट शिफ्ट ऑपरेटर प्रदान करता है।
बिटवाइज और बिट शिफ्ट ऑपरेटरों का उपयोग पूर्णांक (int, long, etc) और बूलियन डेटा पर बिट स्तर के संचालन के लिए किया जाता है। इन ऑपरेटरों को आमतौर पर वास्तविक जीवन स्थितियों में उपयोग नहीं किया जाता है।
यदि आप अधिक तलाशने के इच्छुक हैं, तो बिटवाइज़ ऑपरेशंस के व्यावहारिक अनुप्रयोगों पर जाएँ।
C # में उपलब्ध बिटवाइज़ और बिट शिफ्ट ऑपरेटर नीचे सूचीबद्ध हैं।
सी # बिटवाइज़ ऑपरेटर्स की सूची| ऑपरेटर | ऑपरेटर का नाम |
|---|---|
| ~ | बिटवाइज़ पूरक |
| और | बिटवाइज़ और |
| | | बिटवार या |
| ^ | बिटवाइज़ एक्सक्लूसिव या (XOR) |
| << | बिटवाइस लेफ्ट शिफ्ट |
| >> | बिटवाइज़ राइट शिफ्ट |
बिटवार या
Bitwise OR ऑपरेटर द्वारा दर्शाया गया है |। यह दो ऑपरेंड के संबंधित बिट्स पर बिटवाइज़ या ऑपरेशन करता है। यदि बिट्स में से कोई भी है 1, तो परिणाम है 1। अन्यथा परिणाम है 0।
यदि ऑपरेंड प्रकार के हैं bool, तो बिटवाइज़ या ऑपरेशन उनके बीच तार्किक या ऑपरेशन के बराबर है।
उदाहरण के लिए,
14 = 00001110 (बाइनरी में) 11 = 00001011 (बाइनरी में)
OR14 और 11 के बीच बिटवाइज़ ऑपरेशन:
00001110 00001011 -------- 00001111 = 15 (दशमलव में)
उदाहरण 1: बिटवाइज़ या
using System; namespace Operator ( class BitWiseOR ( public static void Main(string() args) ( int firstNumber = 14, secondNumber = 11, result; result = firstNumber | secondNumber; Console.WriteLine("(0) | (1) = (2)", firstNumber, secondNumber, result); ) ) )
जब हम प्रोग्राम चलाते हैं, तो आउटपुट होगा:
14 | ११ = १५
बिटवाइज़ और
बिटवाइज और ऑपरेटर द्वारा प्रतिनिधित्व किया जाता है &। यह दो ऑपरेंड के संबंधित बिट्स पर बिटवाइज़ और ऑपरेशन करता है। यदि बिट्स में से कोई भी है 0, तो परिणाम है 0। अन्यथा परिणाम है 1।
यदि ऑपरेंड प्रकार के हैं bool, तो बिटवाइज़ और ऑपरेशन उनके बीच तार्किक और ऑपरेशन के बराबर है।
उदाहरण के लिए,
14 = 00001110 (बाइनरी में) 11 = 00001011 (बाइनरी में)
14 और 11 के बीच बिटवाइज़ और ऑपरेशन:
00001110 00001011 -------- 00001010 = 10 (दशमलव में)
उदाहरण 2: बिटवाइज़ और
using System; namespace Operator ( class BitWiseAND ( public static void Main(string() args) ( int firstNumber = 14, secondNumber = 11, result; result = firstNumber & secondNumber; Console.WriteLine("(0) & (1) = (2)", firstNumber, secondNumber, result); ) ) )
जब हम प्रोग्राम चलाते हैं, तो आउटपुट होगा:
14 और 11 = 10
बिटवाइज़ XOR
बिटवाइज XOR ऑपरेटर द्वारा प्रतिनिधित्व किया जाता है ^। यह दो ऑपरेंड के संबंधित बिट्स पर बिटवाइज़ XOR ऑपरेशन करता है। यदि संबंधित बिट समान हैं , तो परिणाम है 0। यदि संबंधित बिट्स भिन्न हैं , तो परिणाम है 1।
यदि ऑपरेंड प्रकार के होते हैं bool, तो बिटवाइज़ XOR ऑपरेशन उनके बीच तार्किक XOR ऑपरेशन के बराबर होता है।
उदाहरण के लिए,
14 = 00001110 (बाइनरी में) 11 = 00001011 (बाइनरी में)
14 और 11 के बीच बिटवाइर XOR ऑपरेशन:
00001110 00001011 -------- 00000101 = 5 (दशमलव में)
यदि आप बिटवाइज़ XOR के उपयोग के बारे में अधिक जानना चाहते हैं, तो The Magic of XOR पर जाएँ
उदाहरण 3: बिटवाइज़ XOR
using System; namespace Operator ( class BitWiseXOR ( public static void Main(string() args) ( int firstNumber = 14, secondNumber = 11, result; result = firstNumber^secondNumber; Console.WriteLine("(0) (1) = (2)", firstNumber, secondNumber, result); ) ) )
जब हम प्रोग्राम चलाते हैं, तो आउटपुट होगा:
14 11 = 5
बिटवाइज़ पूरक
Bitwise Complement operator is represented by ~. It is a unary operator, i.e. operates on only one operand. The ~ operator inverts each bits i.e. changes 1 to 0 and 0 to 1.
For Example,
26 = 00011010 (In Binary)
Bitwise Complement operation on 26:
~ 00011010 = 11100101 = 229 (In Decimal)
Example 4: Bitwise Complement
using System; namespace Operator ( class BitWiseComplement ( public static void Main(string() args) ( int number = 26, result; result = ~number; Console.WriteLine("~(0) = (1)", number, result); ) ) )
When we run the program, the output will be:
~26 = -27
We got -27 as output when we were expecting 229. Why did this happen?
It happens because the binary value 11100101 which we expect to be 229 is actually a 2's complement representation of -27. Negative numbers in computer are represented in 2's complement representation.
For any integer n, 2's complement of n will be -(n+1).
| दशमलव | बाइनरी | 2 का पूरक |
|---|---|---|
| ० | 00000000 | - (11111111 + 1) = -00000000 = -0 (दशमलव में) |
| 1 है | 00000001 | - (11111110 + 1) = -11111111 = -256 (दशमलव में) |
| 229 है | 11100101 | - (00011010 + 1) = -00011011 = -27 |
2 के पूरक में अतिप्रवाह मूल्यों की अनदेखी की जाती है।
बिटवाइज़ पूरक 26229 (दशमलव में) और 2 का पूरक 229है -27। इसलिए आउटपुट -27इसके बजाय है 229।
बिटवाइस लेफ्ट शिफ्ट
बिटवाइज लेफ्ट शिफ्ट ऑपरेटर द्वारा प्रतिनिधित्व किया जाता है <<। <<ऑपरेटर बिट्स की एक निर्धारित संख्या द्वारा छोड़ा के लिए एक नंबर में बदलाव। शून्य को कम से कम महत्वपूर्ण बिट्स में जोड़ा जाता है।
दशमलव में, यह बराबर है
संख्या * 2 वर्ग
उदाहरण के लिए,
42 = 101010 (बाइनरी में)
42 पर बिटवाइज़ लिफ्ट शिफ्ट ऑपरेशन:
42 << 1 = 84 (बाइनरी 1010100 में) 42 << 2 = 168 (बाइनरी 10101000 में) 42 << 4 = 672 (बाइनरी 1010100000 में)
उदाहरण 5: बिटवाइज़ लेफ्ट शिफ्ट
using System; namespace Operator ( class LeftShift ( public static void Main(string() args) ( int number = 42; Console.WriteLine("(0)<<1 = (1)", number, number<<1); Console.WriteLine("(0)<<2 = (1)", number, number<<2); Console.WriteLine("(0)<<4 = (1)", number, number<<4); ) ) )
जब हम प्रोग्राम चलाते हैं, तो आउटपुट होगा:
42 << 1 = 84 42 << 2 = 168 42 << 4 = 672
बिटवाइज़ राइट शिफ्ट
बिटवाइज लेफ्ट शिफ्ट ऑपरेटर द्वारा प्रतिनिधित्व किया जाता है >>। >>ऑपरेटर बिट्स के एक निर्धारित संख्या से सही करने के लिए एक नंबर में बदलाव। पहले ऑपरेंड को दूसरे ऑपरेंड द्वारा निर्दिष्ट बिट्स की संख्या से दाईं ओर स्थानांतरित किया जाता है।
दशमलव में, यह बराबर है
मंजिल (संख्या / 2 वर्ग)
उदाहरण के लिए,
42 = 101010 (बाइनरी में)
42 पर बिटवाइज़ लिफ्ट शिफ्ट ऑपरेशन:
42 >> 1 = 21 (बाइनरी 010101 में) 42 >> 2 = 10 (बाइनरी 001010 में) 42 >> 4 = 2 (बाइनरी 000010 में)
उदाहरण 6: बिटवाइज़ राइट शिफ्ट
using System; namespace Operator ( class LeftShift ( public static void Main(string() args) ( int number = 42; Console.WriteLine("(0)>>1 = (1)", number, number>>1); Console.WriteLine("(0)>>2 = (1)", number, number>>2); Console.WriteLine("(0)>>4 = (1)", number, number>>4); ) ) )
जब हम प्रोग्राम चलाते हैं, तो आउटपुट होगा:
42 >> 1 = 21 42 >> 2 = 10 42 >> 4 = 2
