Integrální číselné typy (referenční dokumentace jazyka C#)

  • Článek

Celočíselné typy představují celočíselná čísla. Všechny integrální číselné typy jsou hodnotové typy. Jsou to také jednoduché typy a dají se inicializovat pomocí literálů. Všechny celočíselné číselné typy podporují aritmetické, bitové logické, porovnání a operátory rovnosti .

Charakteristiky integrálních typů

Jazyk C# podporuje následující předdefinované integrální typy:

Typ nebo klíčové slovo jazyka C# Rozsah Velikost Typ .NET
sbyte -128 až 127 Podepsané 8bitové celé číslo System.SByte
byte 0 až 255 Celé číslo bez znaménka System.Byte
short -32 768 až 32 767 Podepsané 16bitové celé číslo System.Int16
ushort 0 až 65 535 Celé číslo bez znaménka System.UInt16
int -2 147 483 648 až 2 147 483 647 Podepsané 32bitové celé číslo System.Int32
uint 0 až 4 294 967 295 Celé číslo bez znaménka System.UInt32
long -9 223 372 036 854 775 808 až 9 223 372 036 854 775 807 Podepsané 64bitové celé číslo System.Int64
ulong 0 až 18 446 744 073 709 551 615 Celé číslo bez znaménka System.UInt64
nint Závisí na platformě (vypočítané za běhu) Podepsané 32bitové nebo 64bitové celé číslo System.IntPtr
nuint Závisí na platformě (vypočítané za běhu) 32bitové nebo 64bitové celé číslo bez znaménka System.UIntPtr

Ve všech řádcích tabulky s výjimkou posledních dvou je každé klíčové slovo typu jazyka C# z levého sloupce alias pro odpovídající typ .NET. Název klíčového slova a typu .NET jsou zaměnitelné. Například následující deklarace deklarují proměnné stejného typu:

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

Typy nint v nuint posledních dvou řádcích tabulky jsou celá čísla v nativní velikosti. Pomocí kontextových nuint klíčových slov můžete nint definovat celá čísla nativní velikosti. Jedná se o 32bitová celá čísla při spuštění v 32bitovém procesu nebo 64bitových celých čísel při spuštění v 64bitovém procesu. Dají se použít pro scénáře spolupráce, knihovny nízké úrovně a pro optimalizaci výkonu ve scénářích, ve kterých se celočíselná matematika používá široce.

Celočíselné typy nativní velikosti jsou interně reprezentovány jako typy System.IntPtr .NET a System.UIntPtr. Počínaje jazykem C# 11 nint jsou typy nuint aliasy pro podkladové typy.

Výchozí hodnota každého celočíselného typu je nula, 0.

Každý z integrálních typů má MinValue a MaxValue vlastnosti, které poskytují minimální a maximální hodnotu tohoto typu. Tyto vlastnosti jsou konstanty v čase kompilace s výjimkou případu nativních typů velikosti (nint a nuint). Vlastnosti MinValue se MaxValue počítají za běhu pro typy nativní velikosti. Velikosti těchto typů závisí na nastavení procesu.

System.Numerics.BigInteger Struktura slouží k reprezentaci signed integer bez horních nebo dolních hranic.

Celočíselné literály

Celočíselné literály můžou být

  • decimal: bez předpony
  • hexadecimální: s předponou nebo 0X předponou 0x
  • binární: s předponou nebo 0B předponou 0b

Následující kód ukazuje příklad každého z nich:

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

Předchozí příklad také ukazuje použití _ jako oddělovač číslic. Oddělovač číslic můžete použít se všemi druhy číselných literálů.

Typ celočíselného literálu je určen příponou následujícím způsobem:

  • Pokud literál nemá příponu, jeho typ je první z následujících typů, ve kterých může být jeho hodnota reprezentována: int, , uintlong, ulong.

    Poznámka:

    Literály jsou interpretovány jako kladné hodnoty. Literál 0xFF_FF_FF_FF například představuje číslo 4294967295uint typu, i když má stejné bitové vyjádření jako číslo -1int typu. Pokud potřebujete hodnotu určitého typu, přetypování literálu na tento typ. unchecked Operátor použijte, pokud hodnotu literálu nelze reprezentovat v cílovém typu. Například unchecked((int)0xFF_FF_FF_FF) vytvoří -1.

  • Pokud je literál příponou U nebo u, jeho typ je první z následujících typů, ve kterých může být jeho hodnota reprezentována: uint, ulong.

  • Pokud je literál příponou L nebo l, jeho typ je první z následujících typů, ve kterých může být jeho hodnota reprezentována: long, ulong.

    Poznámka:

    Malá písmena l můžete použít jako příponu. To však vygeneruje upozornění kompilátoru, protože písmeno l může být zaměňováno s číslicí 1. Slouží L k přehlednosti.

  • Pokud je literál příponou UL, , Ul, uluL, LU, LulU, nebo lu, jeho typ je ulong.

Pokud hodnota reprezentovaná celočíselnou literál překročí UInt64.MaxValue, dojde k chybě kompilátoru CS1021 .

Pokud je určený typ celočíselného literálu int a hodnota reprezentovaná literálem je v rozsahu cílového typu, může být hodnota implicitně převedena na sbyte, , shortbyte, ushort, uint, , ulong, nint nebo nuint:

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

Jak ukazuje předchozí příklad, pokud hodnota literálu není v rozsahu cílového typu, dojde k chybě kompilátoru CS0031 .

Pomocí přetypování můžete také převést hodnotu reprezentovanou celočíselnou literálou na jiný typ než určený typ literálu:

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

Převody

Jakýkoli celočíselný číselný typ můžete převést na jakýkoli jiný celočíselný číselný typ. Pokud cílový typ může uložit všechny hodnoty zdrojového typu, převod je implicitní. V opačném případě je nutné k provedení explicitního převodu použít výraz přetypování. Další informace naleznete v tématu Předdefinované číselné převody.

Celá čísla s nativní velikostí

Nativní celočíselné typy mají zvláštní chování, protože úložiště je určeno přirozeným celočíselnou velikostí na cílovém počítači.

  • Pokud chcete získat velikost celočíselného čísla nativní velikosti za běhu, můžete použít sizeof(). Kód však musí být zkompilován v nebezpečném kontextu. Příklad:

    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

    Ekvivalentní hodnotu můžete získat také ze statických IntPtr.Size vlastností a UIntPtr.Size vlastností.

  • Chcete-li získat minimální a maximální hodnoty celých čísel nativní velikosti za běhu, použijte MinValue a MaxValue jako statické vlastnosti s nint klíčovými nuint slovy, jak je znázorněno v následujícím příkladu:

    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

  • Konstantní hodnoty můžete použít v následujících oblastech:

  • Kompilátor poskytuje implicitní a explicitní převody na jiné číselné typy. Další informace naleznete v tématu Předdefinované číselné převody.

  • Pro celočíselné literály v nativní velikosti neexistuje žádná přímá syntaxe. Neexistuje žádná přípona označující, že literál je celé číslo v nativní velikosti, například L označení long. Místo toho můžete použít implicitní nebo explicitní přetypování jiných celočíselné hodnoty. Příklad:

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

specifikace jazyka C#

Další informace najdete v následujících částech specifikace jazyka C#:

Viz také