सी # सांख्यिक स्थिरांक

Question

मैं है निम्नलिखित सी # कोड:

byte rule = 0; 
... 
rule = rule | 0x80; 

जो त्रुटि पैदा करता है:

Cannot implicitly convert type 'int' to 'byte'. An explicit conversion exists (are you missing a cast?)

[अद्यतन: सवाल का पहला संस्करण था गलत ... मैं संकलक उत्पादन पढ़ने में भूलना

:]

डाली जोड़ना समस्या नहीं तय करता है

rule |= 0x80; 

सिर्फ अजीब लगता है कौन सा:

मैं के रूप में यह लिखने के लिए की जरूरत है। |= ऑपरेटर | ऑपरेटर से अलग क्यों है?

क्या बाईटर के रूप में निरंतर इलाज करने के लिए कंपाइलर को बताने का कोई अन्य तरीका है?

---

@ जियोवानी Galbo: हां और ना। कोड बाहरी डिवाइस में फ्लैश मेमोरी के प्रोग्रामिंग से निपट रहा है, और तार्किक रूप से स्मृति के एक बाइट का प्रतिनिधित्व करता है। मैं इसे बाद में डाल सकता था, लेकिन यह और अधिक स्पष्ट लग रहा था। मुझे लगता है कि मेरी सी विरासत बहुत ज्यादा दिखा रही है!

@ जोनाथन हॉलैंड: '' के रूप में वाक्य रचना neater लग रहा लेकिन दुर्भाग्य से काम करने के लिए प्रकट नहीं होता है ... यह पैदा करता है:

The as operator must be used with a reference type or nullable type ('byte' is a non-nullable value type)

Answer 1

int rule = 0; 
rule |= 0x80; 

http://msdn.microsoft.com/en-us/library/kxszd0kx.aspx | ऑपरेटर सभी मूल्य प्रकारों के लिए परिभाषित किया गया है। मुझे लगता है कि यह इच्छित परिणाम तैयार करेगा। "| =" ऑपरेटर एक या उसके बाद ऑपरेटर असाइन करता है, जो नियम = नियम के लिए बस लघुरूप है 0x80।

के बारे में सी # niftier बातों में से एक यह है कि आप दुरुपयोग मूल्य प्रकार केवल अपने आकार के आधार पर की तरह पागल बातें करने की सुविधा देता है। एक 'int' बिल्कुल बाइट के समान होता है, सिवाय इसके कि संकलक चेतावनी फेंक देगा यदि आप कोशिश करते हैं और एक ही समय में दोनों का उपयोग करते हैं। बस एक के साथ चिपके हुए (इस मामले में, int) अच्छी तरह से काम करता है। यदि आप 64 बिट तैयारी के बारे में चिंतित हैं, तो आप int32 निर्दिष्ट कर सकते हैं, लेकिन सभी चींट int32s हैं, यहां तक ​​कि x64 मोड में भी चल रहे हैं।

Answer 2

ऐसा लगता है कि तुम सिर्फ यह बदसूरत तरह से करना पड़ सकता है : http://msdn.microsoft.com/en-us/library/5bdb6693.aspx।

Answer 3

सी # बाइट के लिए एक शाब्दिक प्रत्यय नहीं है। u = uint, l = long, ul = ulong, f = float, m = दशमलव, लेकिन कोई बाइट नहीं। आपको इसे कास्ट करना है।

Answer 4

जो शब्द आप खोज रहे हैं वह "शाब्दिक" है और दुर्भाग्य से सी # में बाइट शाब्दिक नहीं है।

यहां all C# literals की एक सूची है।

Answer 5

ECMA Specification, pg 72 के अनुसार कोई बाइट शाब्दिक नहीं है। प्रकारों के लिए केवल पूर्णांक अक्षर: int, uint, long, और ulong।

Answer 6

दुर्भाग्यवश, आपका एकमात्र सहारा यह है कि आप इसे अपने तरीके से करें। शाब्दिक को बाइट के रूप में चिह्नित करने के लिए कोई प्रत्यय नहीं है। द ऑपरेटर एक असाइनमेंट के रूप में अंतर्निहित रूपांतरण प्रदान नहीं करता है (यानी प्रारंभिक) होगा।

Answer 7

यह काम करता है:

rule = (byte)(rule | 0x80); 

जाहिर अभिव्यक्ति 'नियम | 0x80 'अगर आप 0x80 को' const बाइट 0x80 'के रूप में परिभाषित करते हैं तो भी एक int लौटाता है।

Answer 8

Apparently the expression 'rule | 0x80' returns an int even if you define 0x80 as 'const byte 0x80'.

मुझे लगता है कि नियम 0x80 डिफ़ॉल्ट रूप से int की तरह है जब तक आप एक शाब्दिक प्रत्यय शामिल नहीं करते। तो अभिव्यक्ति rule | 0x80 के लिए, परिणाम एक int होगा क्योंकि 0x80 एक int और नियम है (जो एक बाइट है) सुरक्षित रूप से int में परिवर्तित किया जा सकता है।

Answer 9

सी मानक के अनुसार, हमेशा भाव, यहां तक ​​कि स्थिरांक में int करने के लिए बढ़ावा देने के बाइट्स। हालांकि, जब तक दोनों मूल्यों को अनसुलझा किया जाता है, तब तक उच्च-आदेश बिट्स को त्याग दिया जाएगा ताकि ऑपरेशन को सही मूल्य वापस कर दिया जाए।

इसी तरह, तैरता दोगुना करने के लिए, आदि को बढ़ावा देने कश्मीर & आर की कॉपी से बाहर

पुल यह वहाँ में सब है।

Answer 10

लगभग पांच साल पर और कोई भी वास्तव में सवाल का जवाब दे गया है।

जवाब में से एक जोड़े का दावा है कि समस्या एक बाइट शाब्दिक की कमी है, लेकिन इस अप्रासंगिक है। यदि आप (byte1 | byte2) की गणना करते हैं तो परिणाम int टाइप करें। यहां तक ​​कि अगर "बी" बाइट के लिए एक शाब्दिक प्रत्यय थे (23b | 32b) के प्रकार अभी भी int होगा।

एक एमएसडीएन आलेख के स्वीकृत उत्तर लिंक का दावा है कि operator| सभी अभिन्न प्रकारों के लिए परिभाषित किया गया है, लेकिन यह भी सच नहीं है।

operator|byte पर परिभाषित नहीं किया गया है, इसलिए संकलक int पर परिभाषित संस्करण को चुनने के लिए अपने सामान्य ओवरलोड रिज़ॉल्यूशन नियमों का उपयोग करता है। इसलिए, यदि आप एक byte के परिणाम प्रदान करना चाहते हैं तो आप इसे कास्ट करने के लिए की जरूरत है:

rule = (byte)(rule | 0x80); 

सवाल रहता है, यही कारण है कि rule |= 0x80; काम करता है?

क्योंकि सी # विनिर्देश है कि आप स्पष्ट रूपांतरण छोड़ करने की अनुमति देता यौगिक काम के लिए एक विशेष नियम है। यौगिक असाइनमेंट x op= y नियम में है:

if the selected operator is a predefined operator, if the return type of the selected operator is explicitly convertible to the type of x, and if y is implicitly convertible to the type of x or the operator is a shift operator, then the operation is evaluated as x = (T)(x op y) , where T is the type of x, except that x is evaluated only once.