Share via

Integrale numerieke typen (C#-verwijzing)

  • Artikel

De integrale numerieke typen vertegenwoordigen gehele getallen. Alle integrale numerieke typen zijn waardetypen. Ze zijn ook eenvoudige typen en kunnen worden geïnitialiseerd met letterlijke gegevens. Alle integrale numerieke typen ondersteunen rekenkundige, bitgewijze logische, vergelijkings- en gelijkheidsoperatoren.

Kenmerken van de integrale typen

C# ondersteunt de volgende vooraf gedefinieerde integrale typen:

C#-type/trefwoord Bereik Tekengrootte .NET-type
sbyte -128 tot 127 Ondertekend 8-bits geheel getal System.SByte
byte 0 tot 255 Niet-ondertekend 8-bits geheel getal System.Byte
short -32.768 tot 32.767 Ondertekend 16-bits geheel getal System.Int16
ushort 0 tot 65.535 Niet-ondertekend 16-bits geheel getal System.UInt16
int -2.147.483.648 tot 2.147.483.647 Ondertekend 32-bits geheel getal System.Int32
uint 0 tot 4.294.967.295 Niet-ondertekend 32-bits geheel getal System.UInt32
long -9.223.372.036.854.775.808 tot 9.223.372.036.854.775.807 Ondertekend 64-bits geheel getal System.Int64
ulong 0 tot 18.446.744.073.709.551.615 Niet-ondertekend 64-bits geheel getal System.UInt64
nint Afhankelijk van het platform (berekend tijdens runtime) Ondertekend 32-bits of 64-bits geheel getal System.IntPtr
nuint Afhankelijk van het platform (berekend tijdens runtime) Niet-ondertekend 32-bits of 64-bits geheel getal System.UIntPtr

In alle tabelrijen behalve de laatste twee is elk C#-type trefwoord uit de meest linkse kolom een alias voor het bijbehorende .NET-type. De naam van het trefwoord en het .NET-type zijn uitwisselbaar. De volgende declaraties declareren bijvoorbeeld variabelen van hetzelfde type:

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

De nint en nuint typen in de laatste twee rijen van de tabel zijn gehele getallen van systeemeigen grootte. U kunt de nint en nuint contextuele trefwoorden gebruiken om gehele getallen van systeemeigen grootte te definiëren. Dit zijn 32-bits gehele getallen wanneer ze worden uitgevoerd in een 32-bits proces of 64-bits gehele getallen wanneer ze worden uitgevoerd in een 64-bits proces. Ze kunnen worden gebruikt voor interop-scenario's, bibliotheken op laag niveau en om de prestaties te optimaliseren in scenario's waarin berekeningen met gehele getallen uitgebreid worden gebruikt.

De typen gehele getallen van systeemeigen grootte worden intern weergegeven als de .NET-typen System.IntPtr en System.UIntPtr. Vanaf C# 11 zijn de nint en nuint typen aliassen voor de onderliggende typen.

De standaardwaarde van elk integraaltype is nul, 0.

Elk van de integrale typen heeft MinValue en MaxValue eigenschappen die de minimum- en maximumwaarde van dat type bieden. Deze eigenschappen zijn compileertijdconstanten, met uitzondering van het geval van de typen van systeemeigen grootte (nint en nuint). De MinValue eigenschappen en MaxValue eigenschappen worden tijdens runtime berekend voor typen van systeemeigen grootte. De grootte van deze typen is afhankelijk van de procesinstellingen.

Gebruik de System.Numerics.BigInteger structuur om een ondertekend geheel getal zonder boven- of ondergrens weer te geven.

Letterlijke waarden voor gehele getallen

Letterlijke waarden voor gehele getallen kunnen zijn

  • decimaal: zonder voorvoegsel
  • hexadecimaal: met het 0x of 0X voorvoegsel
  • binair: met het 0b of 0B voorvoegsel

In de volgende code ziet u een voorbeeld van elk van deze code:

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

In het voorgaande voorbeeld ziet u ook het gebruik van _ als scheidingsteken voor cijfers. U kunt het scheidingsteken voor cijfers gebruiken met allerlei numerieke letterlijke waarden.

Het type letterlijke geheel getal wordt als volgt bepaald door het achtervoegsel:

  • Als de letterlijke waarde geen achtervoegsel heeft, is het type het eerste van de volgende typen waarin de waarde kan worden weergegeven: int, uint, , long, . ulong

    Notitie

    Letterlijke waarden worden geïnterpreteerd als positieve waarden. De letterlijke waarde 0xFF_FF_FF_FF vertegenwoordigt bijvoorbeeld het nummer 4294967295 van het uint type, hoewel deze dezelfde bitweergave heeft als het nummer -1 van het int type. Als u een waarde van een bepaald type nodig hebt, cast dan een letterlijke waarde naar dat type. Gebruik de unchecked operator als een letterlijke waarde niet kan worden weergegeven in het doeltype. Produceert -1bijvoorbeeld unchecked((int)0xFF_FF_FF_FF) .

  • Als de letterlijke waarde is achtervoegsel of uU , is het type de eerste van de volgende typen waarin de waarde ervan kan worden weergegeven: uint, ulong.

  • Als de letterlijke waarde is achtervoegsel of lL , is het type de eerste van de volgende typen waarin de waarde ervan kan worden weergegeven: long, ulong.

    Notitie

    U kunt de kleine letter l als achtervoegsel gebruiken. Hiermee wordt echter een compilerwaarschuwing gegenereerd omdat de letter l kan worden verward met het cijfer 1. Gebruik L dit voor duidelijkheid.

  • Als de letterlijke tekst is achtervoegsel door , , , , , LULu, lUof lu, het type is ulong. uluLUlUL

Als de waarde die wordt vertegenwoordigd door een letterlijk geheel getal groter is UInt64.MaxValue, treedt er een compilerfout CS1021 op.

Als het bepaald type van een letterlijk geheel getal is int en de waarde die wordt vertegenwoordigd door de letterlijke waarde zich binnen het bereik van het doeltype bevindt, kan de waarde impliciet worden geconverteerd naar sbyte, byte, short, ushort, , uint, of nintulongnuint:

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

Zoals in het voorgaande voorbeeld wordt weergegeven, treedt er een compilerfout CS0031 op als de waarde van de letterlijke waarde zich niet binnen het bereik van het doeltype bevindt.

U kunt ook een cast gebruiken om de waarde die wordt vertegenwoordigd door een letterlijk geheel getal te converteren naar het andere type dan het bepaald type van de letterlijke waarde:

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

Conversies

U kunt elk integraal numeriek type converteren naar elk ander integraal numeriek type. Als het doeltype alle waarden van het brontype kan opslaan, is de conversie impliciet. Anders moet u een cast-expressie gebruiken om een expliciete conversie uit te voeren. Zie ingebouwde numerieke conversies voor meer informatie.

Systeemeigen gehele getallen

Systeemeigen typen gehele getallen hebben een speciaal gedrag omdat de opslag wordt bepaald door de natuurlijke gehele getalgrootte op de doelcomputer.

  • Als u de grootte van een geheel getal van systeemeigen grootte tijdens runtime wilt ophalen, kunt u gebruiken sizeof(). De code moet echter worden gecompileerd in een onveilige context. Voorbeeld:

    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

    U kunt ook de equivalente waarde ophalen uit de statische IntPtr.Size en UIntPtr.Size eigenschappen.

  • Als u de minimum- en maximumwaarden van gehele getallen van systeemeigen grootte tijdens runtime wilt ophalen, gebruikt MinValue u en MaxValue als statische eigenschappen met de nint en nuint trefwoorden, zoals in het volgende voorbeeld:

    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

  • U kunt constante waarden in de volgende bereiken gebruiken:

  • De compiler biedt impliciete en expliciete conversies naar andere numerieke typen. Zie ingebouwde numerieke conversies voor meer informatie.

  • Er is geen directe syntaxis voor letterlijke gehele getallen van systeemeigen grootte. Er is geen achtervoegsel om aan te geven dat een letterlijk geheel getal een systeemeigen geheel getal is, zoals L een long. U kunt in plaats daarvan impliciete of expliciete casts van andere gehele getallen gebruiken. Voorbeeld:

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

C#-taalspecificatie

Zie de volgende secties van de C#-taalspecificatie voor meer informatie:

Zie ook