Freigeben über

Integrale numerische Typen (C#-Referenz)

Die integralen numerischen Typen stellen ganze Zahlen dar. Alle integralen numerischen Typen sind Werttypen. Die integralen Typen sind einfache Typen und können mit Literalen initialisiert werden. Alle integralen numerischen Typen unterstützen arithmetische, bitweise logische, Vergleichs- und Gleichheitsoperatoren .

Merkmale der integralen Typen

C# unterstützt die folgenden vordefinierten Integraltypen:

C#-Typ/Schlüsselwort Range Größe .NET-Typ
sbyte -128 bis 127 Signierte 8-Bit-Ganzzahl System.SByte
byte 0 bis 255 Nicht signierte 8-Bit-Ganzzahl System.Byte
short -32.768 bis 32.767 Signierte 16-Bit-Ganzzahl System.Int16
ushort 0 bis 65.535 Nicht signierte 16-Bit-Ganzzahl System.UInt16
int -2.147.483.648 bis 2.147.483.647 32-Bit-Ganzzahl System.Int32
uint 0 bis 4.294.967.295 Nicht signierte 32-Bit-Ganzzahl System.UInt32
long -9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807 64-Bit-Ganzzahl System.Int64
ulong 0 bis 18.446.744.073.709.551.615 Nicht signierte 64-Bit-Ganzzahl System.UInt64
nint Hängt von der Plattform ab (zur Laufzeit berechnet) Signierte 32-Bit- oder 64-Bit-Ganzzahl System.IntPtr
nuint Hängt von der Plattform ab (zur Laufzeit berechnet) Nicht signierte 32-Bit- oder 64-Bit-Ganzzahl System.UIntPtr

In allen Tabellenzeilen mit Ausnahme der letzten beiden Zeilen ist jedes C#-Typ-Schlüsselwort aus der spalte ganz links ein Alias für den entsprechenden .NET-Typ. Das Schlüsselwort und der .NET-Typname sind austauschbar. Die folgenden Deklarationen deklarieren beispielsweise Variablen desselben Typs:

int a = 123;
System.Int32 b = 123;

Die nint- und nuint-Typen in den letzten beiden Zeilen der Tabelle sind Integerwerte mit nativer Größe. Sie können die nint und nuint kontextbezogenen Schlüsselwörter verwenden, um Ganzzahlen nativer Größe zu definieren. Ganzzahlen in systemeigener Größe sind 32-Bit-Ganzzahlen, wenn sie in einem 32-Bit-Prozess ausgeführt werden, oder 64-Bit-Ganzzahlen, wenn sie in einem 64-Bit-Prozess ausgeführt werden. Sie können für Interoperabilitätsszenarien, Bibliotheken auf niedriger Ebene und zur Optimierung der Leistung in Szenarien verwendet werden, in denen ganzzahlige Mathematik umfassend verwendet wird.

Die ganzzahligen Typen der nativen Größe werden intern als .NET-Typen System.IntPtr und System.UIntPtr dargestellt. Die nint Typen nuint sind Aliase für die zugrunde liegenden Typen.

Der Standardwert jedes integralen Typs ist Null, 0.

Jeder der integralen Typen hat die Eigenschaften MinValue und MaxValue, die den minimalen und maximalen Wert dieses Typs bereitstellen. Diese Eigenschaften sind Kompilierzeit-Konstanten, mit Ausnahme der Typen nativer Größe (nint und nuint). Die Eigenschaften MinValue und MaxValue werden zur Laufzeit für Typen mit nativer Größe berechnet. Die Größen dieser Typen hängen von den Prozesseinstellungen ab.

Verwenden Sie die System.Numerics.BigInteger Struktur, um eine signierte ganze Zahl ohne obere oder untere Grenzen darzustellen.

Ganzzahlenliteral

Ganzzahlenliterale können die folgenden Typen aufweisen:

  • Dezimalzahl: ohne Präfix
  • de-DE: hexadezimal: mit dem 0x oder 0X Präfix
  • binär: mit dem 0b oder 0B Präfix

Der folgende Code veranschaulicht ein Beispiel für jede:

var decimalLiteral = 42;
var hexLiteral = 0x2A;
var binaryLiteral = 0b_0010_1010;

Das vorangehende Beispiel zeigt auch die Verwendung von _ als Zifferntrennzeichen. Sie können das Zifferntrennzeichen mit allen Arten numerischer Literale verwenden.

Das Suffix bestimmt den Typ eines ganzzahligen Literals wie folgt:

  • Wenn das Literal kein Suffix aufweist, ist sein Typ der erste der folgenden Typen, in denen sein Wert dargestellt werden kann: int, , , uint. longulong

    Hinweis

    Literale werden als positive Werte interpretiert. Beispielsweise stellt das Literal 0xFF_FF_FF_FF die Nummer 4294967295 des uint Typs dar, obwohl es dieselbe Bitdarstellung wie die Nummer -1 des int Typs aufweist. Wenn Sie einen Wert eines bestimmten Typs benötigen, können Sie ein Literal in diesen Typ umwandeln. Verwenden Sie den unchecked Operator, wenn kein Literalwert im Zieltyp dargestellt werden kann. Beispielsweise erzeugt unchecked((int)0xFF_FF_FF_FF) den Wert -1.

  • Wenn das Literal das Uu Oder-Suffix enthält, ist sein Typ der erste der folgenden Typen, in denen sein Wert dargestellt werden kann: uint, ulong.

  • Wenn das Literal das Ll Oder-Suffix enthält, ist sein Typ der erste der folgenden Typen, in denen sein Wert dargestellt werden kann: long, ulong.

    Hinweis

    Sie können den Kleinbuchstaben l als Suffix verwenden. Generiert jedoch eine Compilerwarnung, l da der Buchstabe l mit der Ziffer 1verwechselt werden kann. Verwenden Sie L um Übersichtlichkeit zu erreichen.

  • Wenn das Literal eines der UL: , Ul, uL, ul, , LULu, lUoder lu Suffixe enthält, ist ulongder Typ .

Wenn der durch ein ganzzahliges Literal dargestellte Wert überschritten wird UInt64.MaxValue, tritt ein Compilerfehler CS1021 auf.

Wenn der bestimmte Typ eines ganzzahligen Literals und int der durch das Literal dargestellte Wert innerhalb des Bereichs des Zieltyps liegt, kann der Wert implizit sbytein , , byte, , short, ushort, uint, , ulong, , oder nintnuint:

byte a = 17;
byte b = 300;   // CS0031: Constant value '300' cannot be converted to a 'byte'

Wie im vorherigen Beispiel gezeigt, tritt ein Compilerfehler CS0031 auf, wenn der Literalwert nicht innerhalb des Zieltyps liegt.

Sie können auch eine Umwandlung verwenden, um den Wert, der durch ein Ganzzahlliteral dargestellt wird, in einen anderen Typ als den festgelegten Literaltyp zu konvertieren:

var signedByte = (sbyte)42;
var longVariable = (long)42;

Konvertierungen

Sie können einen beliebigen integralen numerischen Typ in einen anderen integralen numerischen Typ konvertieren. Wenn der Zieltyp alle Werte des Quelltyps speichern kann, ist die Konvertierung implizit. Andernfalls müssen Sie einen Cast-Ausdruck verwenden, um eine explizite Konvertierung durchzuführen. Weitere Informationen finden Sie unter den integrierten numerischen Konvertierungen.

Integerwerte mit nativer Größe

Systemeigene ganzzahlige Typen weisen ein spezielles Verhalten auf, da der Speicher mit der natürlichen ganzzahligen Größe auf dem Zielcomputer übereinstimmt.

  • Zum Abrufen der Größe eines Integers in nativer Größe zur Laufzeit können Sie sizeof() verwenden. Der Code muss jedoch in einem unsicheren Kontext kompiliert werden. Beispiel:

    Console.WriteLine($"size of nint = {sizeof(nint)}");
Console.WriteLine($"size of nuint = {sizeof(nuint)}");

// output when run in a 64-bit process
//size of nint = 8
//size of nuint = 8

// output when run in a 32-bit process
//size of nint = 4
//size of nuint = 4

    Sie können auch den entsprechenden Wert aus den statischen IntPtr.Size und UIntPtr.Size Eigenschaften abrufen.

  • Um die Mindest- und Höchstwerte von Integer-Zahlen während der Laufzeit zu ermitteln, verwenden Sie MinValue und MaxValue als statische Eigenschaften mit den Schlüsselwörtern nint und nuint, wie im folgenden Beispiel gezeigt:

    Console.WriteLine($"nint.MinValue = {nint.MinValue}");
Console.WriteLine($"nint.MaxValue = {nint.MaxValue}");
Console.WriteLine($"nuint.MinValue = {nuint.MinValue}");
Console.WriteLine($"nuint.MaxValue = {nuint.MaxValue}");

// output when run in a 64-bit process
//nint.MinValue = -9223372036854775808
//nint.MaxValue = 9223372036854775807
//nuint.MinValue = 0
//nuint.MaxValue = 18446744073709551615

// output when run in a 32-bit process
//nint.MinValue = -2147483648
//nint.MaxValue = 2147483647
//nuint.MinValue = 0
//nuint.MaxValue = 4294967295

  • Während der gesamte Bereich von nint und nuint kann größer sein, sind Kompilierungszeitkonstanten auf einen 32-Bit-Bereich beschränkt:

  • Der Compiler stellt implizite und explizite Konvertierungen in andere numerische Typen bereit. Weitere Informationen finden Sie unter den integrierten numerischen Konvertierungen.

  • Es gibt keine direkte Syntax für Integer-Literale in nativer Größe. Es gibt kein Suffix, das angibt, dass es sich bei einem Literal um einen Integerwert mit nativer Größe handelt (wie L, um long anzugeben). Sie können stattdessen implizite oder explizite Umwandlungen von anderen Integerwerten verwenden. Beispiel:

    nint a = 42
nint a = (nint)42;

C#-Sprachspezifikation

Weitere Informationen finden Sie in den folgenden Abschnitten der C#-Sprachspezifikation:

Siehe auch

  • Last updated on