Sdílet prostřednictvím

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

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/klíčové slovo jazyka C# Rozmezí 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 Neznaménkové 32bitové celé číslo 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 Neznamenkové 64bitové celé číslo 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 klíčových slov nint a nuint můžete definovat celá čísla nativní velikosti. Jedná se o 32bitová celá čísla při spuštění v 32bitovém procesu, nebo o 64bitová celá čísla 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 verzí C# 11, jsou typy nint a nuint aliasy pro základní 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 a MaxValue se počítají během běhu programu 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 0x nebo předponou 0X
  • binární: s 0b nebo 0B předponou

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 se interpretují 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řetypujte literál na tento typ. Použijte operátor unchecked, 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 s příponou UL, Ul, uL, ul, LU, Lu, lU, 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, , byteshort, 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číselným literálem na typ, který se liší od určeného typu tohoto 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é použít výraz přetypování k explicitnímu převodu. Další informace naleznete v tématu Předdefinované číselné převody.

Celá čísla s nativní velikostí

Nativní datové typy celých čísel mají zvláštní chování, protože úložiště je určeno nativní celočíselnou velikostí na cílovém počítači.

  • Pokud chcete získat velikost celočíselné nativní velikosti za běhu programu, můžete použít sizeof(). Kód však musí být zkompilován v nebezpečném kontextu. Napří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 klíčovými slovy nint a nuint, 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

  • Zatímco úplný rozsah nint a nuint může být větší, konstanty času kompilace jsou omezeny na 32bitový rozsah:

  • 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é celočíselné hodnoty. Napří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é

  • Last updated on