Partilhar via

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

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

Características dos tipos integrais

O C# suporta os seguintes tipos integrais predefinidos:

Tipo/palavra-chave C# Alcance 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 contextuais nint e nuint para definir inteiros de tamanho nativo. Os inteiros de tamanho nativo são inteiros de 32 bits quando a correr num processo de 32 bits, ou inteiros de 64 bits quando a correr num 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. Os nint tipos e nuint são pseudónimos dos 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 propriedades MinValue 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 sufixo determina o tipo de um literal inteiro 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.

    Observação

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

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

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

    Observação

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

  • Se o literal inclui um dos ULsufixos , Ul, uL, ul, LULu, lU, , , ou lu sufixos, o seu tipo é 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 pode ser implicitamente convertido em sbyte, byte, short, uintushort, , ulong, nint, , 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 de inteiros de tamanho nativo têm um comportamento especial porque o armazenamento corresponde ao tamanho natural do inteiro na máquina de destino.

  • Para obter o tamanho de um inteiro de tamanho nativo em tempo de execução, pode usar sizeof(). 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 das propriedades estáticas IntPtr.Size e UIntPtr.Size.

  • 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

  • Embora o intervalo completo de nint e nuint possa ser maior, as constantes de compilação estão restritas a um intervalo de 32 bits:

  • 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#:

Ver também

  • Last updated on