Compartir a través de

Tipos numéricos enteros (referencia de C#)

Los tipos numéricos enteros representan números enteros. Todos los tipos numéricos enteros son tipos de valor. Los tipos enteros son tipos simples y se inicializan con literales. Todos los tipos numéricos enteros admiten operadores aritméticos, lógicos de bits, de comparación e igualdad.

La referencia del lenguaje C# documenta la versión publicada más recientemente del lenguaje C#. También contiene documentación inicial sobre las características de las versiones preliminares públicas de la próxima versión del lenguaje.

La documentación identifica cualquier característica introducida por primera vez en las últimas tres versiones del idioma o en las versiones preliminares públicas actuales.

Sugerencia

Para buscar cuándo se introdujo por primera vez una característica en C#, consulte el artículo sobre el historial de versiones del lenguaje C#.

Características de los tipos enteros

C# admite los siguientes tipos enteros predefinidos:

Tipo o palabra clave de C# Intervalo Tamaño Tipo de .NET
sbyte -128 a 127 Entero de 8 bits con signo System.SByte
byte De 0 a 255 Entero de 8 bits sin signo System.Byte
short -32.768 a 32.767 Entero de 16 bits con signo System.Int16
ushort De 0 a 65 535 Entero de 16 bits sin signo System.UInt16
int -2.147.483.648 a 2.147.483.647 Entero de 32 bits firmado System.Int32
uint De 0 a 4.294.967.295 Entero de 32 bits sin signo System.UInt32
long De -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807 Entero de 64 bits firmado System.Int64
ulong De 0 a 18 446 744 073 709 551 615 Entero de 64 bits sin signo System.UInt64
nint Depende de la plataforma (calculada en tiempo de ejecución) Entero de 64 bits o 32 bits con signo System.IntPtr
nuint Depende de la plataforma (calculada en tiempo de ejecución) Entero de 32 o 64 bits sin signo System.UIntPtr

En todas las filas de tabla excepto las dos últimas, cada palabra clave de tipo de C# de la columna situada más a la izquierda es un alias para el tipo de .NET correspondiente. La palabra clave y el nombre de tipo de .NET son intercambiables. Por ejemplo, las declaraciones siguientes declaran variables del mismo tipo:

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

Los tipos nint y nuint de las dos últimas filas de la tabla son enteros de tamaño nativo. Puede usar las nint palabras clave contextuales y nuint para definir enteros de tamaño nativo. Los enteros de tamaño nativo son enteros de 32 bits cuando se ejecutan en un proceso de 32 bits o enteros de 64 bits cuando se ejecutan en un proceso de 64 bits. Úselos para escenarios de interoperabilidad, bibliotecas de bajo nivel y para optimizar el rendimiento en escenarios en los que se usan operaciones matemáticas de enteros ampliamente.

Los tipos enteros de tamaño nativo se representan internamente como los tipos System.IntPtr de .NET y System.UIntPtr. Los nint tipos y nuint son alias para los tipos subyacentes.

El valor predeterminado de cada tipo entero es cero, 0.

Cada uno de los tipos enteros tiene MinValue y MaxValue propiedades que proporcionan el valor mínimo y máximo de ese tipo. Estas propiedades son constantes en tiempo de compilación, excepto para el caso de los tipos de tamaño nativo (nint y nuint). Las propiedades MinValue y MaxValue se calculan en tiempo de ejecución de tipos de tamaño nativo. Los tamaños de esos tipos dependen de la configuración del proceso.

Use la System.Numerics.BigInteger estructura para representar un entero con signo sin límites superiores o inferiores.

Literales enteros

Los literales enteros pueden ser:

  • decimal: sin ningún prefijo
  • hexadecimal: con el prefijo 0x o 0X
  • binary: con el prefijo 0b o el prefijo 0B

En el código siguiente se muestra un ejemplo de cada uno:

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

En el ejemplo anterior también se muestra el uso de _ como separador de dígitos. Puede usar el separador de dígitos con todo tipo de literales numéricos.

El sufijo determina el tipo de un literal entero de la siguiente manera:

  • Si el literal no tiene sufijo, el compilador asigna el tipo como el primero de los siguientes tipos en los que se puede representar su valor: int, uint, long, ulong.

    Nota:

    El compilador interpreta literales como valores positivos. Por ejemplo, el literal 0xFF_FF_FF_FF representa el número 4,294,967,295 del uint tipo, aunque tiene la misma representación de bits que el número -1 del int tipo. Si necesita un valor de un tipo determinado, convierta un literal en ese tipo. Use el unchecked operador si no se puede representar un valor literal en el tipo de destino. Por ejemplo, unchecked((int)0xFF_FF_FF_FF) genera -1.

  • Si el literal incluye el U sufijo o u , el compilador asigna el tipo como el primero de los siguientes tipos en los que se puede representar su valor: uint, ulong.

  • Si el literal incluye el L sufijo o l , el compilador asigna el tipo como el primero de los siguientes tipos en los que se puede representar su valor: long, ulong.

    Nota:

    Puede usar la letra l minúscula como sufijo. Sin embargo, l genera una advertencia del compilador porque la letra l se puede confundir con el dígito 1. Se usa L para mayor claridad.

  • Si el literal incluye uno de los ULsufijos , Ul, lULUulLuuL, o lu , el compilador asigna el tipo como .ulong

Si el valor representado por un literal entero supera UInt64.MaxValue, se produce un error del compilador CS1021 .

Si el compilador determina el tipo de un literal entero como int y el valor representado por el literal está dentro del intervalo del tipo de destino, el valor se puede convertir implícitamente en sbyte, , uintushortshortulongbyte, , , o : nintnuint

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

Como se muestra en el ejemplo anterior, si el valor del literal no está dentro del intervalo del tipo de destino, se produce un error del compilador CS0031 .

También puede usar una conversión para convertir el valor representado por un literal entero en un tipo que no sea el determinado del literal:

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

Conversiones

Puede convertir cualquier tipo numérico entero a cualquier otro tipo numérico entero. Si el tipo de destino puede almacenar todos los valores del tipo de origen, la conversión es implícita. De lo contrario, use una expresión de conversión para realizar una conversión explícita. Para obtener más información, consulte Conversiones numéricas integradas.

Enteros con tamaño nativos

Los tipos enteros de tamaño nativo tienen un comportamiento especial porque el almacenamiento coincide con el tamaño entero natural en la máquina de destino.

  • Para obtener el tamaño de un entero de tamaño nativo en tiempo de ejecución, use sizeof(). Sin embargo, el código debe compilarse en un contexto no seguro. Por ejemplo:

    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

    También puede obtener el valor equivalente de las propiedades estáticas IntPtr.Size y UIntPtr.Size .

  • Para obtener los valores mínimos y máximos de enteros de tamaño nativo en tiempo de ejecución, use MinValue y MaxValue como propiedades estáticas con las nint palabras clave y nuint , como en el ejemplo siguiente:

    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

  • Aunque el intervalo completo de y nint puede ser mayor, las constantes en tiempo de compilación están restringidas a un intervalo de nuint 32 bits:

  • El compilador proporciona conversiones implícitas y explícitas a otros tipos numéricos. Para obtener más información, consulte Conversiones numéricas integradas.

  • No hay ninguna sintaxis directa para literales enteros de tamaño nativo. No hay ningún sufijo para indicar que un literal es un entero de tamaño nativo, como L para indicar un long. Use conversiones implícitas o explícitas de otros valores enteros en su lugar. Por ejemplo:

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

Especificación del lenguaje C#

Para más información, vea las secciones siguientes de la Especificación del lenguaje C#:

Consulte también

  • Last updated on