C# numerische Konstanten

Question

Ich habe den folgenden C# -Code:

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

, die die Fehler produziert:

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

[Update: erste Version der Frage falsch war ... ich die Compiler Ausgabe falsch gelesen ]

die Besetzung Hinzufügen nicht beheben nicht das Problem:

rule = rule | (byte) 0x80; 

muss ich es so schreiben:

rule |= 0x80; 

Welche einfach seltsam scheint. Warum unterscheidet sich der Operator |= von dem Operator |?

Gibt es eine andere Möglichkeit, dem Compiler mitzuteilen, dass die Konstante als Byte behandelt werden soll?

---

@ Giovanni Galbo: ja und nein. Der Code behandelt die Programmierung des Flash-Speichers in einem externen Gerät und stellt logisch ein einzelnes Speicherbyte dar. Ich könnte es später werfen, aber das schien mehr offensichtlich. Ich denke, mein C-Erbe zeigt zu viel!

@ Jonathon Holland: die ‚als‘ Syntax ordentlicheres aussieht, aber leider scheint nicht zu funktionieren ... es produziert:

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 Die | Operator ist für alle Werttypen definiert. Ich denke, das wird das beabsichtigte Ergebnis bringen. Der Operator "| =" ist ein oder dann ein Operator, der einfach eine Abkürzung für rule = rule | ist 0x80.

Eines der nobleren Dinge an C# ist, dass Sie damit verrückte Dinge wie Missbrauch Werttypen einfach auf ihre Größe basieren können. Ein 'int' ist genau dasselbe wie ein Byte, außer dass der Compiler Warnungen ausgibt, wenn Sie versuchen, sie beide gleichzeitig zu verwenden. Einfach mit einem (in diesem Fall int) zu kleben funktioniert gut. Wenn Sie über die 64-Bit-Bereitschaft besorgt sind, können Sie int32 angeben, aber alle Ints sind int32s und werden sogar im x64-Modus ausgeführt.

Answer 2

Sieht aus wie Sie es gerade die hässliche Art und Weise haben zu tun : http://msdn.microsoft.com/en-us/library/5bdb6693.aspx.

Answer 3

C# hat kein Literalsuffix für Byte. u = uint, l = lang, ul = ulong, f = float, m = dezimal, aber kein Byte. Sie müssen es umsetzen.

Answer 4

Der Begriff, nach dem Sie suchen, ist "Literal" und leider hat C# kein Byte-Literal.

Hier ist eine Liste von all C# literals.

Answer 5

Gemäß ECMA Specification, pg 72 gibt es kein Byte-Literal. Nur Ganzzahlliterale für die Typen int, uint, long und ulong.

Answer 6

Leider ist Ihre einzige Möglichkeit, es so zu tun, wie Sie haben. Es gibt kein Suffix, um das Literal als Byte zu kennzeichnen. Das | Der Operator sieht keine implizite Umwandlung als eine Zuweisung (d. h. Initialisierung) vor.

Answer 7

Dies funktioniert:

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

Anscheinend ist der Ausdruck ‚Regel | 0x80 'gibt ein int zurück, selbst wenn Sie 0x80 als' const Byte 0x80 'definieren.

Answer 8

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

Ich denke, die Regel Zahlen wie 0x80 Standardwerte ist in int, wenn Sie eine wörtliche Suffix enthalten. Für den Ausdruck rule | 0x80 wird das Ergebnis ein int sein, da 0x80 ein int ist und eine Regel (die ein Byte ist) sicher in int umgewandelt werden kann.

Answer 9

Gemäß dem C-Standard werden Bytes IMMER für int in Ausdrücken, sogar Konstanten, unterstützt. Solange beide Werte UNSIGNED sind, werden die höherwertigen Bits verworfen, so dass die Operation den korrekten Wert zurückgeben sollte.

Ähnlich Schwimmer fördern zu verdoppeln, usw.

Pull aus Kopie von K & R. alles drin ist es schon.

Answer 10

Fast fünf Jahre später hat niemand die Frage beantwortet.

Ein paar Antworten behaupten, dass das Problem das Fehlen eines Byte-Literals ist, aber das ist irrelevant. Wenn Sie (byte1 | byte2) berechnen, ist das Ergebnis vom Typ int. Selbst wenn "b" ein Literalsuffix für Byte wäre, wäre der Typ (23b | 32b) immer noch int.

Die akzeptierte Antwort verweist auf einen MSDN-Artikel, der behauptet, dass operator| für alle Integraltypen definiert ist, aber das stimmt auch nicht.

operator| ist nicht definiert auf byte so dass der Compiler verwendet, um seine übliche Überladungsauflösung Regeln für die Version auswählen, die auf int definiert ist. Wenn Sie also das Ergebnis einer byte zuweisen möchten, müssen Sie es werfen:

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

Es bleibt die Frage, warum tut rule |= 0x80; Arbeit?

Da die C# -Spezifikation eine spezielle Regel für die Verbundzuweisung enthält, können Sie die explizite Konvertierung weglassen. In der Verbundbelegung x op= y lautet die Regel:

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.