Integrale numerieke typen (C#-verwijzing)

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:

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 en MaxValue eigenschappen worden tijdens uitvoeringstijd 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

De volgende code demonstreert een voorbeeld van elk:

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 getallen gebruiken met allerlei numerieke letterwaarden.

Het type van een integer-letterlijke wordt bepaald door het achtervoegsel als volgt:

• 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

  Opmerking

  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 unchecked((int)0xFF_FF_FF_FF)bijvoorbeeld -1 .

• Als het getal is voorzien van het achtervoegsel U of u, is het type het eerste van de volgende typen waarin de waarde ervan kan worden weergegeven: uint, ulong.

• Als het getal is voorzien van het achtervoegsel L of l, is het type het eerste van de volgende typen waarin de waarde ervan kan worden weergegeven: long, ulong.

  Opmerking

  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 achtervoegd door UL, Ul, uL, ul, LU, Lu, lU, of lu, is het type ulong.

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 ulongnintnuint:

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 integer literal te converteren naar een ander type dan het bepaalde type van de literal.

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 geschaalde gehele getallen

Natuurlijke gehele getaltypen hebben een speciaal gedrag doordat de opslag wordt bepaald door het natuurlijke gehele getalformaat 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
  

• Hoewel het volledige bereik van nint en nuint mogelijk groter is, zijn compilatieconstanten beperkt tot een 32-bits bereik:

  • Voor nint: Int32.MinValue naar Int32.MaxValue.
  • Voor nuint: UInt32.MinValue naar UInt32.MaxValue.

• 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 dat aangeeft dat een literal een inheemse grootte van een 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:

• Integrale typen
• Letterlijke waarden voor gehele getallen
• Integrale typen van systeemeigen grootte
• C# 11 - Numeriek IntPtr en UIntPtr

Zie ook

• waardetypen
• Typen drijvende komma
• Standaardtekenreeksen voor numerieke notatie
• Numerieke waarden in .NET