सी ++ से सी #

Question

से कुछ बिट शिफ्ट कोड को दोबारा उत्पादित करना मैं सी ++ कोड से सी # कोड पर एक एनम को कन्वर्ट करने की कोशिश कर रहा हूं, और मुझे इसके चारों ओर अपने सिर को लपेटने में परेशानी हो रही है। सी ++ कोड है:

enum FOO { 
    FOO_1 = 0, 
    FOO_2, 
    // etc 
} 

#define MASK(x) ((1 << 16) | (x)) 

enum DISP 
{ 
    DISP_1 = MASK(FOO_1), 
    DISP_2 = MASK(FOO_2), 
    // etc 
} 

मैं क्या समझ में नहीं आता क्या मुखौटा कर रहा है, और कैसे मैं या तो सी # में कार्यक्षमता का अनुकरण कर सकते हैं या समझते हैं कि यह क्या कर रही है और इसके बिना मैन्युअल enum DISP निर्धारित किया है।

मुझे यकीन नहीं है कि मैं जो कह रहा हूं वह समझ में आता है, लेकिन यह उम्मीद की जा सकती है जब मैं पूरी तरह से निश्चित नहीं हूं कि मैं क्या देख रहा हूं।

Answer 1

MASK(x) एक द्विआधारी संख्या 10000000000000000 (एक छोड़ दिया 16 बार में स्थानांतरित कर दिया) के साथ एक नंबर x में आईएनजी OR से एक नंबर निर्माण करती है।

सी # में आप एक अभिव्यक्ति सीधे उपयोग कर सकते हैं, इस तरह:

enum FOO { 
    FOO_1 = 0, 
    FOO_2, 
    // etc 
} 

enum DISP 
{ 
    DISP_1 = (1<<16) | (int)(FOO.FOO_1), 
    DISP_2 = (1<<16) | (int)(FOO.FOO_2), 
    // etc 
} 

Answer 2

बस क्या यह रूप में परिभाषित किया गया है के साथ MASK की जगह (<< और | ऑपरेटरों भी सी # में मौजूद):

enum DISP 
{ 
    DISP_1 = ((1 << 16) | FOO.FOO_1), 
    DISP_2 = ((1 << 16) | FOO.FOO_2) 
} 

---

आप सोच रहे हैं कि वास्तव में क्या बदलाव और या ऑपरेटरों करते हैं, आप ' 0000000000000001 का बाइनरी मान ले रहा है और इसे बाईं ओर 16 मानों को स्थानांतरित करता है: 1000000000000000।

एक और उदाहरण, (000001101 << 3)001101000 बन जाता है।

या ऑपरेटर या तो संकार्य से सभी 1 मानों का उपयोग करके करने के लिए 1.

उदाहरण के लिए परिणाम का मूल्य निर्धारित करता है, 0001 | 01100111 हो जाता है।

तो फिर, DISP_2 ले:

(0b00000000000000001 << 16) | 0b00000000000000010) 
= (0b10000000000000000 | 0b00000000000000010) 
= (0b10000000000000010) 
= 65538 

(मैं जानता हूँ कि 0b प्रारूप सी # में काम नहीं करता और सी में मानक नहीं है, लेकिन यह हेक्साडेसिमल के बजाय द्विआधारी संकेतन का उपयोग करने के लिए अधिक उपयोगी है आसान, ऑपरेटरों क्या कर रहे हैं देखने के लिए)

Answer 3

जब आप बदलाव सा है, यह बाईं ओर या सही मूल्यों के कुछ संख्या से सब 1 है और 0 है बदलाव।

आपके मामले में 1 << 16 बाइनरी में 10000000000000000 बनाता है। (हाँ यह 16 शून्य है)।

फिर यह संख्या लेता है और | का उपयोग करता है जो कि बिटवाई-ऑपरेटर है। इस प्रकार, जो भी enum का पूर्णांक मान है, वह उस संख्या में थोड़ा सा हो जाता है जिसे हम थोड़ा सा स्थानांतरित करते हैं।

उदाहरण के लिए, आप MASK(FOO_4) का उपयोग करते हैं (जिसमें 3 का शाब्दिक मूल्य है) 3 बाइनरी में 11 है, इसलिए परिणाम 10000000000000011 होगा। यह कार्यात्मक रूप से प्रत्येक मान पर 65,536 जोड़ने जैसा ही है।

अब, जब हम दूसरे enum घोषित करते हैं, हम उन अजीब मास्किंग फ़ंक्शन में उन enum मानों के मान सेट कर रहे हैं।

enum Foo { //this may not be needed anymore? 
    FOO_1 = 0, FOO_2, ... etc 
} 

enum Disp { //DISP_2 gets the next value ie 65536 + 1, and so forth 
    DISP_1 = 65536, DISP_2, DISP_3, ... etc 

Answer 4

सांख्यिक मानों कि DISP_x बराबर हैं:

C# इस कोशिश में एक ही बात करने के लिए

DISP_1 == 0x10000 
DISP_2 == 0x10001 
DISP_3 == 0x10002 
... 

Answer 5

बिट पारी ऑपरेटर सी # में काम करता है, लेकिन परिभाषित मैक्रो नहीं करता ' टी।

को समझने के लिए क्या कर सकते हैं आप हो रहा है अलग से मूल्यों की गणना और फिर उन्हें enum में डाल रहा है।

बेशक आप जानते हैं कि | बिटवाई या ऑपरेटर है।

1 << 16 = 10000000000000000_2 //those are 16 zeroes and _2 indicates binary 

बारी में: और बस के मामले में क्या ऑपरेटर << करता बाईं ओर द्विआधारी बदलाव है

10000000000000000_2 = 65536 

संख्या 2 से ने संकेत दिया समय की संख्या mutiplying की quivalent है दूसरा ऑपरेंड।

1 << 1 = 2 
1 << 2 = 4 
1 << 3 = 8 

यह सही है, यह दोनों का एक शक्ति से संख्या से गुणा है:

1 << 1 <=> 1 * 2^1 = 2 
1 << 2 <=> 1 * 2^2 = 4 
1 << 3 <=> 1 * 2^3 = 8 

अब, FOO_2 के लिए तो FOO_1 = 0

DISP_1 = MASK(FOO_1) 
=> 
DISP_1 = ((1 << 16) | (FOO_1)) 
=> 
DISP_1 = (65536 | (FOO_1)) 
=> 
DISP_1 = (65536 | FOO_1) 
=> 
DISP_1 = (65536 | 0) 
=> 
DISP_1 = 65536 

ही कर के बाद से जो मैं ले गया है मान 1 आपको देगा:

DISP_2 = (65536 | FOO_2) 
=> 
DISP_2 = (65536 | 1) 
=> 
DISP_2 = 65537 

---

इसी के साथ

निम्न कार्य सही ढंग से कहा:

enum FOO 
{ 
    FOO_1 = 0, 
    FOO_2, 
    // etc 
} 

enum DISP 
{ 
    DISP_1 = (1<<16) | (int)(FOO.FOO_1), 
    DISP_2 = (1<<16) | (int)(FOO.FOO_2), 
    // etc 
}