Dela via

Integral numeriska typer (C#-referens)

De numeriska heltalstyperna representerar heltalsnummer. Alla integrerade numeriska typer är värdetyper. Integraltyperna är enkla typer och du initierar dem med literaler. Alla integrerade numeriska typer stöder aritmetiska, bitvis logiska operatorer, jämförelse- och likhetsoperatorer .

C#-språkreferensen dokumenterar den senaste versionen av C#-språket. Den innehåller även inledande dokumentation för funktioner i offentliga förhandsversioner för den kommande språkversionen.

Dokumentationen identifierar alla funktioner som först introducerades i de tre senaste versionerna av språket eller i aktuella offentliga förhandsversioner.

Tips/Råd

Information om när en funktion först introducerades i C# finns i artikeln om språkversionshistoriken för C#.

Egenskaper för de integrerade typerna

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

C#-typ/nyckelord Räckvidd 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 heltal med 64 bitar 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;

Typerna nint och nuint i de två sista raderna i tabellen är heltal i nativ storlek. Du kan använda de kontextuella nyckelorden nint och nuint för att definiera heltal i inbyggd storlek. Heltal i intern storlek ä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. Använd dem 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. Typerna nint och nuint är 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 typer med inbyggd storlek. 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 siffraavgränsare. Du kan använda sifferavgränsaren med alla typer av numeriska literaler.

Suffixet avgör typen av en heltalsliteral enligt följande:

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

    Anmärkning

    Kompilatorn tolkar literaler som positiva värden. Till exempel representerar literalen 0xFF_FF_FF_FF antalet 4,294,967,295 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 innehåller suffixet U eller u tilldelar kompilatorn typen som den första av följande typer där dess värde kan representeras: uint, ulong.

  • Om literalen innehåller suffixet L eller l tilldelar kompilatorn typen som den första av följande typer där dess värde kan representeras: long, ulong.

    Anmärkning

    Du kan använda den gemena bokstaven l som ett suffix. Genererar dock l en kompilatorvarning eftersom bokstaven l kan förväxlas med siffran 1. Använd L för tydlighetens skull.

  • Om literalen innehåller något av suffixen UL, Ul, uLul, LU, Lu, lUeller lu så tilldelar kompilatorn typen som ulong.

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

Om kompilatorn fastställer typen av en heltalsliteral som och värdet som int representeras av literalen ligger inom måltypens intervall, kan värdet implicit konverteras till sbyte, byte, short, ushort, uint, ulong, ninteller nuint:

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 cast för att konvertera värdet som representeras av en heltalsliteral till en annan typ än den bestämda typen av literalen.

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 använder du ett cast-uttryck för att utföra en explicit konvertering. För mer information, se inbyggda numeriska konverteringar.

Heltal i naturlig storlek

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

  • Om du vill hämta storleken på ett heltal i intern storlek vid körning använder du 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 få minimivärden och maxvärden för helttal anpassade till processorarkutekturen vid körning, använder du MinValue 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

  • Även om hela intervallet av nint och nuint kan vara större, begränsas kompileringstidskonstanter till ett 32-bitarsintervall:

  • Kompilatorn tillhandahåller implicita och explicita konverteringar till andra numeriska typer. För mer information, se 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. Använd 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

  • Last updated on