Integral numeriska typer (C#-referens)

  • Artikel

De numeriska heltalstyperna representerar heltalsnummer. Alla integrerade numeriska typer är värdetyper. De är också enkla typer och kan initieras med literaler. Alla integrerade numeriska typer stöder aritmetiska, bitvis logiska operatorer, jämförelse- och likhetsoperatorer .

Egenskaper för de integrerade typerna

C# stöder följande fördefinierade integraltyper:

C#-typ/nyckelord Intervall Storlek .NET-typ
sbyte -128 till 127 Signerat 8-bitars heltal System.SByte
byte 0 till 255 Osignerat 8-bitars heltal System.Byte
short -32 768 till 32 767 Signerat 16-bitars heltal System.Int16
ushort 0 till 65 535 Osignerat 16-bitars heltal System.UInt16
int -2 147 483 648 till 2 147 483 647 Signerat 32-bitars heltal System.Int32
uint 0 till 4 294 967 295 Osignerat 32-bitars heltal System.UInt32
long -9 223 372 036 854 775 808 till 9 223 372 036 854 775 807 Signerat 64-bitars heltal System.Int64
ulong 0 till 18 446 744 073 709 551 615 Osignerat 64-bitars heltal System.UInt64
nint Beror på plattform (beräknas vid körning) Signerat 32-bitars eller 64-bitars heltal System.IntPtr
nuint Beror på plattform (beräknas vid körning) Osignerat 32-bitars eller 64-bitars heltal System.UIntPtr

I alla tabellrader utom de två sista är varje C#-typnyckelord från kolumnen längst till vänster ett alias för motsvarande .NET-typ. Nyckelordet och .NET-typnamnet är utbytbara. Följande deklarationer deklarerar till exempel variabler av samma typ:

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

Och-typerna nintnuint i de två sista raderna i tabellen är heltal i intern storlek. Du kan använda nint kontextuella nyckelord och nuint för att definiera inbyggda heltal. Det här är 32-bitars heltal när de körs i en 32-bitarsprocess eller 64-bitars heltal när de körs i en 64-bitarsprocess. De kan användas för heltalsscenarier, bibliotek på låg nivå och för att optimera prestanda i scenarier där heltalsmatematik används i stor utsträckning.

De inbyggda heltalstyperna representeras internt som .NET-typerna System.IntPtr och System.UIntPtr. Från och med C# 11 är typerna nint och nuint alias för de underliggande typerna.

Standardvärdet för varje integraltyp är noll, 0.

Var och en av de integrerade typerna har MinValue och MaxValue egenskaper som ger det lägsta och högsta värdet för den typen. Dessa egenskaper är kompileringstidskonstanter förutom för de inbyggda typerna (nint och nuint). Egenskaperna MinValue och MaxValue beräknas vid körning för inbyggda typer. Storleken på dessa typer beror på processinställningarna.

System.Numerics.BigInteger Använd strukturen för att representera ett signerat heltal utan övre eller nedre gränser.

Heltalsliteraler

Heltalsliteraler kan vara

  • decimal: utan prefix
  • hexadecimal: med prefixet 0x eller 0X
  • binär: med prefixet 0b eller 0B

Följande kod visar ett exempel på var och en:

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

I föregående exempel visas också användningen av _ som en sifferavgränsare. Du kan använda sifferavgränsaren med alla typer av numeriska literaler.

Typen av en heltalsliteral bestäms av dess suffix på följande sätt:

  • Om literalen inte har något suffix är dess typ den första av följande typer där dess värde kan representeras: int, uint, long, ulong.

    Kommentar

    Literaler tolkas som positiva värden. Till exempel representerar literalen 0xFF_FF_FF_FF antalet 4294967295 av uint typen, även om den har samma bitrepresentation som antalet -1 av int typen. Om du behöver ett värde av en viss typ gjuter du en literal till den typen. Använd operatorn unchecked om ett literalvärde inte kan representeras i måltypen. Till unchecked((int)0xFF_FF_FF_FF) exempel genererar -1.

  • Om literalen är suffixet av U eller uär dess typ den första av följande typer där dess värde kan representeras: uint, ulong.

  • Om literalen är suffixet av L eller lär dess typ den första av följande typer där dess värde kan representeras: long, ulong.

    Kommentar

    Du kan använda gemener l som suffix. Detta genererar dock en kompilatorvarning eftersom bokstaven l kan förväxlas med siffran 1. Använd L för tydlighetens skull.

  • Om literalen är suffixet av UL, Ul, uL, ul, LU, Lu, , lUeller lu, är ulongdess typ .

Om värdet som representeras av en heltalsliteral överskrider UInt64.MaxValueuppstår ett kompilatorfel CS1021 .

Om den fastställda typen av en heltalsliteral är int och värdet som representeras av literalen ligger inom måltypens intervall, kan värdet implicit konverteras till sbyte, byte, short, ushort, uint, ulongeller nintnuint:

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

Som föregående exempel visar uppstår ett kompilatorfel CS0031 om literalvärdet inte ligger inom måltypens intervall.

Du kan också använda en gjuten för att konvertera värdet som representeras av en heltalsliteral till den typ som inte är den bestämda typen av literal:

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

Omvandlingar

Du kan konvertera valfri numerisk typ av integral till valfri annan numerisk typ. Om måltypen kan lagra alla värden av källtypen är konverteringen implicit. Annars måste du använda ett cast-uttryck för att utföra en explicit konvertering. Mer information finns i Inbyggda numeriska konverteringar.

Heltal i intern storlek

Inbyggda heltalstyper har ett särskilt beteende eftersom lagringen bestäms av den naturliga heltalsstorleken på måldatorn.

  • Om du vill få storleken på ett heltal i intern storlek vid körning kan du använda sizeof(). Koden måste dock kompileras i en osäker kontext. Till exempel:

    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

    Du kan också hämta motsvarande värde från statiska IntPtr.Size värden och UIntPtr.Size egenskaper.

  • Om du vill hämta lägsta och högsta värden för inbyggda heltal vid körning använder MinValue du och MaxValue som statiska egenskaper med nyckelorden nint och nuint som i följande exempel:

    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

  • Du kan använda konstanta värden i följande intervall:

  • Kompilatorn tillhandahåller implicita och explicita konverteringar till andra numeriska typer. Mer information finns i Inbyggda numeriska konverteringar.

  • Det finns ingen direkt syntax för heltal i intern storlek. Det finns inget suffix som anger att en literal är ett heltal i intern storlek, till exempel L för att ange ett long. Du kan använda implicita eller explicita avgjutningar av andra heltalsvärden i stället. Till exempel:

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

Språkspecifikation för C#

Mer information finns i följande avsnitt i C#-språkspecifikationen:

Se även