Partilhar via

Tipos numéricos integrais (referência C#)

  • Artigo

Os tipos numéricos integrais representam números inteiros. Todos os tipos numéricos integrais são tipos de valor. Eles também são tipos simples e podem ser inicializados com literais. Todos os tipos numéricos integrais suportam operadores aritméticos, bitwise lógicos, de comparação e de igualdade .

Características dos tipos integrais

O C# suporta os seguintes tipos integrais predefinidos:

Tipo/palavra-chave C# Intervalo Tamanho Tipo .NET
sbyte -128 a 127 Inteiro de 8 bits assinado System.SByte
byte 0 a 255 Inteiro de 8 bits não assinado System.Byte
short -32.768 a 32.767 Inteiro de 16 bits assinado System.Int16
ushort 0 a 65.535 Inteiro de 16 bits não assinado System.UInt16
int -2.147.483.648 a 2.147.483.647 Inteiro de 32 bits assinado System.Int32
uint 0 a 4.294.967.295 Inteiro de 32 bits não assinado System.UInt32
long -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807 Inteiro de 64 bits assinado System.Int64
ulong 0 a 18.446.744.073.709.551.615 Inteiro de 64 bits não assinado System.UInt64
nint Depende da plataforma (computada em tempo de execução) Inteiro de 32 bits ou 64 bits assinado System.IntPtr
nuint Depende da plataforma (computada em tempo de execução) Inteiro de 32 bits ou 64 bits não assinado System.UIntPtr

Em todas as linhas da tabela, exceto nas duas últimas, cada palavra-chave do tipo C# da coluna mais à esquerda é um alias para o tipo .NET correspondente. A palavra-chave e o nome do tipo .NET são intercambiáveis. Por exemplo, as seguintes declarações declaram variáveis do mesmo tipo:

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

Os nint e nuint tipos nas duas últimas linhas da tabela são inteiros de tamanho nativo. Você pode usar as palavras-chave e nuint contextuais nint para definir inteiros de tamanho nativo. Estes são inteiros de 32 bits quando executados em um processo de 32 bits ou inteiros de 64 bits quando executados em um processo de 64 bits. Eles podem ser usados para cenários de interoperabilidade, bibliotecas de baixo nível e para otimizar o desempenho em cenários onde a matemática inteira é usada extensivamente.

Os tipos inteiros de tamanho nativo são representados internamente como os tipos System.IntPtr .NET e System.UIntPtr. A partir do C# 11, os nint tipos e nuint são aliases para os tipos subjacentes.

O valor padrão de cada tipo integral é zero, 0.

Cada um dos tipos integrais tem MinValue e MaxValue propriedades que fornecem o valor mínimo e máximo desse tipo. Essas propriedades são constantes de tempo de compilação, exceto para o caso dos tipos de tamanho nativo (nint e nuint). As MinValue propriedades e MaxValue são calculadas em tempo de execução para tipos de tamanho nativo. Os tamanhos desses tipos dependem das configurações do processo.

Use a System.Numerics.BigInteger estrutura para representar um inteiro assinado sem limites superiores ou inferiores.

Literais inteiros

Literais inteiros podem ser

  • decimal: sem qualquer prefixo
  • hexadecimal: com o prefixo 0x ou 0X
  • binário: com o prefixo 0b ou 0B

O código a seguir demonstra um exemplo de cada um:

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

O exemplo anterior também mostra o uso de como um separador de _ dígitos. Você pode usar o separador de dígitos com todos os tipos de literais numéricos.

O tipo de um literal inteiro é determinado pelo seu sufixo da seguinte forma:

  • Se o literal não tem sufixo, seu tipo é o primeiro dos seguintes tipos em que seu valor pode ser representado: int, uint, long, ulong.

    Nota

    Os literais são interpretados como valores positivos. Por exemplo, o literal 0xFF_FF_FF_FF representa o número 4294967295 do tipo, embora tenha a mesma representação de uint bits que o número -1 do int tipo. Se você precisar de um valor de um determinado tipo, lance um literal para esse tipo. Use o unchecked operador , se um valor literal não puder ser representado no tipo de destino. Por exemplo, unchecked((int)0xFF_FF_FF_FF) produz -1.

  • Se o literal é sufixo por U ou u, seu tipo é o primeiro dos seguintes tipos em que seu valor pode ser representado: uint, ulong.

  • Se o literal é sufixo por L ou l, seu tipo é o primeiro dos seguintes tipos em que seu valor pode ser representado: long, ulong.

    Nota

    Você pode usar a letra l minúscula como sufixo. No entanto, isso gera um aviso do compilador porque a letra l pode ser confundida com o dígito 1. Use L para clareza.

  • Se o literal é sufixo por UL, Ul, uL, ul, LU, lULu, , ou , seu lutipo é ulong.

Se o valor representado por um literal inteiro exceder UInt64.MaxValue, ocorrerá um erro de compilador CS1021 .

Se o tipo determinado de um literal inteiro for int e o valor representado pelo literal estiver dentro do intervalo do tipo de destino, o valor poderá ser implicitamente convertido em sbyte, byte, , ushortshort, uint, ulongnint , ou nuint:

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

Como mostra o exemplo anterior, se o valor do literal não estiver dentro do intervalo do tipo de destino, ocorrerá um erro de compilador CS0031 .

Você também pode usar uma conversão para converter o valor representado por um literal inteiro para o tipo diferente do tipo determinado do literal:

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

Conversões

Você pode converter qualquer tipo numérico integral em qualquer outro tipo numérico integral. Se o tipo de destino puder armazenar todos os valores do tipo de origem, a conversão estará implícita. Caso contrário, você precisará usar uma expressão de transmissão para executar uma conversão explícita. Para obter mais informações, consulte Conversões numéricas internas.

Inteiros de tamanho nativo

Os tipos inteiros de tamanho nativo têm um comportamento especial porque o armazenamento é determinado pelo tamanho inteiro natural na máquina de destino.

  • Para obter o tamanho de um inteiro de tamanho nativo em tempo de execução, você pode usar sizeof()o . No entanto, o código deve ser compilado em um contexto inseguro. Por exemplo:

    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

    Você também pode obter o valor equivalente da estática IntPtr.Size e UIntPtr.Size das propriedades.

  • Para obter os valores mínimo e máximo de inteiros de tamanho nativo em tempo de execução, use MinValue e MaxValue como propriedades estáticas com as nint palavras-chave e nuint , como no exemplo a seguir:

    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

  • Você pode usar valores constantes nos seguintes intervalos:

  • O compilador fornece conversões implícitas e explícitas para outros tipos numéricos. Para obter mais informações, consulte Conversões numéricas internas.

  • Não há sintaxe direta para literais inteiros de tamanho nativo. Não há sufixo para indicar que um literal é um inteiro de tamanho nativo, como L para indicar um long. Em vez disso, você pode usar versões implícitas ou explícitas de outros valores inteiros. Por exemplo:

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

Especificação da linguagem C#

Para obter mais informações, consulte as seguintes seções da especificação da linguagem C#:

Consulte também