byte + byte = int... warum?

Question

Betrachten Sie diesen C#-Code:

byte x = 1;
byte y = 2;
byte z = x + y; // ERROR: Cannot implicitly convert type 'int' to 'byte'

Das Ergebnis der Berechnungen, die an byte (oder short ) wird implizit in eine Ganzzahl zurückgewandelt. Die Lösung besteht darin, das Ergebnis explizit in ein Byte zurückzuwandeln:

byte z = (byte)(x + y); // this works

Ich frage mich nur, warum? Ist es architektonisch? Philosophisch?

Wir haben:

• int + int = int
• long + long = long
• float + float = float
• double + double = double

Warum also nicht?

• byte + byte = byte
• short + short = short ?

Ein wenig Hintergrundinformationen: Ich führe eine lange Liste von Berechnungen mit "kleinen Zahlen" (d.h. < 8) durch und speichere die Zwischenergebnisse in einem großen Array. Mit einer Byte-Array (anstelle eines int-Arrays) ist schneller (wegen der Cache-Treffer). Aber die umfangreichen Byte-Casts, die über den Code verteilt sind, machen ihn noch viel unleserlicher.

Answer 1

Dies ist größtenteils meine Antwort, die sich auf dieses Thema bezieht und zuerst auf eine ähnliche Frage eingereicht wurde aquí .

Alle Operationen mit ganzen Zahlen kleiner als Int32 werden vor der Berechnung standardmäßig auf 32 Bit aufgerundet. Der Grund, warum das Ergebnis Int32 ist, liegt einfach darin, es nach der Berechnung so zu belassen, wie es ist. Wenn Sie die MSIL-Arithmetik-Opcodes überprüfen, sind die einzigen ganzzahligen numerischen Typen, mit denen sie arbeiten, Int32 und Int64. Das ist "by design".

Wenn Sie das Ergebnis im Int16-Format zurückhaben möchten, ist es unerheblich, ob Sie die Umwandlung im Code durchführen oder ob der Compiler (hypothetisch) die Umwandlung "unter der Haube" vornimmt.

Zum Beispiel, um Int16 Arithmetik zu machen:

short a = 2, b = 3;

short c = (short) (a + b);

Die beiden Zahlen würden auf 32 Bits erweitert, addiert und dann auf 16 Bits zurückgeschnitten, so wie es von MS vorgesehen ist.

Der Vorteil der Verwendung von Short (oder Byte) liegt in erster Linie in der Speicherung großer Datenmengen (grafische Daten, Streaming usw.).

Answer 2

Die Addition ist für Bytes nicht definiert. Daher werden sie für die Addition in int umgewandelt. Dies gilt für die meisten mathematischen Operationen und Bytes. (Beachten Sie, dass dies in älteren Sprachen der Fall war, ich gehe davon aus, dass dies auch heute noch so ist).

Answer 3

Ich habe die Leistung zwischen Byte und Int getestet.
Bei int-Werten :

class Program
{
    private int a,b,c,d,e,f;

    public Program()
    {
        a = 1;
        b = 2;
        c = (a + b);
        d = (a - b);
        e = (b / a);
        f = (c * b);
    }

    static void Main(string[] args)
    {
        int max = 10000000;
        DateTime start = DateTime.Now;
        Program[] tab = new Program[max];

        for (int i = 0; i < max; i++)
        {
            tab[i] = new Program();
        }
        DateTime stop = DateTime.Now;

        Debug.WriteLine(stop.Subtract(start).TotalSeconds);
    }
}

Mit Byte-Werten :

class Program
{
    private byte a,b,c,d,e,f;

    public Program()
    {
        a = 1;
        b = 2;
        c = (byte)(a + b);
        d = (byte)(a - b);
        e = (byte)(b / a);
        f = (byte)(c * b);
    }

    static void Main(string[] args)
    {
        int max = 10000000;
        DateTime start = DateTime.Now;
        Program[] tab = new Program[max];

        for (int i = 0; i < max; i++)
        {
            tab[i] = new Program();
        }
        DateTime stop = DateTime.Now;

        Debug.WriteLine(stop.Subtract(start).TotalSeconds);
    }
}

Hier das Ergebnis:
byte : 3.57s 157mo, 3.71s 171mo, 3.74s 168mo mit CPU ~= 30%
int : 4.05s 298mo, 3.92s 278mo, 4.28 294mo mit CPU ~= 27%
Schlussfolgerung:
Byte verbraucht mehr CPU, aber es kostet weniger Speicher und ist schneller (vielleicht weil weniger Byte zugewiesen werden müssen)

Answer 4

Ich denke, es ist eine Design-Entscheidung darüber, welche Operation üblicher war... Wenn Byte+Byte = Byte ist, werden sich vielleicht viel mehr Leute daran stören, dass sie nach int casten müssen, wenn ein int als Ergebnis benötigt wird.

Answer 5

Aus .NET Framework-Code:

// bytes
private static object AddByte(byte Left, byte Right)
{
    short num = (short) (Left + Right);
    if (num > 0xff)
    {
        return num;
    }
    return (byte) num;
}

// shorts (int16)
private static object AddInt16(short Left, short Right)
{
    int num = Left + Right;
    if ((num <= 0x7fff) && (num >= -32768))
    {
        return (short) num;
    }
    return num;
}

Vereinfachen Sie mit .NET 3.5 und höher:

public static class Extensions 
{
    public static byte Add(this byte a, byte b)
    {
        return (byte)(a + b);
    }
}

können Sie jetzt tun:

byte a = 1, b = 2, c; c = a.Add(b);