Compartilhar via

Tipos numéricos integrais (referência de 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 dão suporte a operadores aritméticos, lógicos bit a bit, de comparação e de igualdade.

Características dos tipos integrais

O C# dá suporte aos seguintes tipos integrais predefinidos:

Tipo/palavra-chave em C# Intervalo Tamanho Tipo .NET
sbyte -128 a 127 Inteiro de 8 bits com sinal System.SByte
byte 0 a 255 Número inteiro sem sinal de 8 bits System.Byte
short -32.768 a 32.767 Inteiro de 16 bits com sinal System.Int16
ushort 0 a 65.535 Inteiro de 16 bits sem sinal System.UInt16
int -2.147.483.648 a 2.147.483.647 Inteiro assinado de 32 bits System.Int32
uint 0 a 4.294.967.295 Inteiro de 32 bits sem sinal System.UInt32
long -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807 Inteiro assinado de 64 bits System.Int64
ulong 0 a 18.446.744.073.709.551.615 Inteiro de 64 bits sem sinal System.UInt64
nint Depende da plataforma (computado em tempo de execução) Inteiro de 32 bits ou de 64 bits com sinal System.IntPtr
nuint Depende da plataforma (computado em tempo de execução) Inteiro de 32 bits ou de 64 bits sem sinal 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 tipos nint e nuint nas duas últimas linhas da tabela são inteiros com tamanho nativo. Use as palavras-chave contextuais nint e nuint para definir inteiros de tamanho nativo. Inteiros de tamanho nativo são inteiros de 32 bits ao serem executados em um processo de 32 bits ou inteiros de 64 bits ao serem 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 aritmética de inteiros é 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 os nuint tipos 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 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 estrutura System.Numerics.BigInteger para representar um inteiro com sinal sem limites superiores ou inferiores.

Literais inteiros

Liteais inteiros podem ser

  • decimal: sem nenhum 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 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 maneira:

  • Se o literal não tiver sufixo, seu tipo será o primeiro dos seguintes tipos nos quais seu valor pode ser representado: int, , uint, long. ulong

    Observação

    Os literais são interpretados como valores positivos. Por exemplo, o literal 0xFF_FF_FF_FF representa o número 4294967295 do tipo uint, embora tenha a mesma representação de bit que o número -1 do tipo int. Se você precisar de um valor de um determinado tipo, converta um literal nesse 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 incluir o sufixo ou u o U sufixo, seu tipo será o primeiro dos seguintes tipos nos quais seu valor pode ser representado: uint, ulong.

  • Se o literal incluir o sufixo ou l o L sufixo, seu tipo será o primeiro dos seguintes tipos nos quais 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 maior clareza.

  • Se o literal incluir um dos UL, , Ul, uL, ul, LU, Lu, lUou lu sufixos, seu tipo é ulong.

Se o valor representado por um literal inteiro exceder UInt64.MaxValue, ocorrerá um erro do 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 convertido sbyteimplicitamente em , , byte, short, ushortuint, ulong, , nintou 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 do compilador CS0031 .

Você também pode usar uma coerção para converter o valor representado por um literal inteiro em um tipo diferente do que foi determinado para o 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 será implícita. Caso contrário, você precisará usar uma expressão de cast para executar uma conversão explícita. Para obter mais informações, consulte conversões numéricas internas.

Inteiros de tamanho nativo

Tipos inteiros de tamanho nativo têm um comportamento especial porque o armazenamento corresponde ao tamanho do inteiro natural no computador de destino.

  • Para obter o tamanho de um inteiro de tamanho nativo em tempo de execução, você pode usar sizeof(). No entanto, o código deve ser compilado em um contexto não seguro. 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 palavras-chave nint 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 tempo de compilação sã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 específica para literais inteiros de tamanho nativo. Não há sufixo para indicar que um literal é um inteiro de tamanho nativo, como L indicar um long. Em vez disso, você pode usar conversõ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, confira as seguintes seções da especificação da linguagem C#:

Consulte também

  • Last updated on