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 pueden inicializar con literales. Todos los tipos numéricos enteros admiten operadores aritméticos, lógicos de bits, de comparación e igualdad.

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. Se pueden usar para escenarios de interoperabilidad, bibliotecas de bajo nivel y para optimizar el rendimiento en escenarios en los que las matemáticas de enteros se usan 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, su tipo es el primero de los siguientes tipos en los que se puede representar su valor: int, uint, long, ulong.

    Nota:

    Los literales se interpretan como valores positivos. Por ejemplo, el literal 0xFF_FF_FF_FF representa el número 4294967295 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 un valor literal no se puede representar en el tipo de destino. Por ejemplo, unchecked((int)0xFF_FF_FF_FF) genera -1.

  • Si el literal incluye el U sufijo o u , su tipo es 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 , su tipo es 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 , , LUuLLuUlul, lU, o lu , , su tipo es .ulong

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

Si el tipo determinado de un literal entero es 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, byte, uintushortulongshort, , , ninto :nuint

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, debe usar una expresión Cast 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, puede usar 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 nuint puede ser mayor, las constantes en tiempo de compilación están restringidas a un intervalo de nint 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. En su lugar, puede usar conversiones implícitas o explícitas de otros valores enteros. 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