Rangos de enteros y potencias de dos

Los límites exactos de cada tipo entero de ancho fijo, de 8 a 64 bits, los valores de 2⁶³ y 2⁶⁴ que marcan las fronteras de 64 bits, y una tabla completa de potencias de dos de 2⁰ a 2⁶⁴ en decimal y hexadecimal. Todos los números de esta página se calculan al generarla con aritmética de precisión arbitraria.

Rangos con y sin signo por ancho de bits

Con n bits hay exactamente 2ⁿ patrones distintos; un tipo sin signo los usa todos para ir de 0 a 2ⁿ−1. Un tipo con signo guarda los negativos en complemento a dos y gasta la mitad de los patrones en −2ⁿ⁻¹ … −1, lo que deja 0 … 2ⁿ⁻¹−1 para el lado no negativo: por eso el máximo con signo es 2ⁿ⁻¹−1 y el mínimo es −2ⁿ⁻¹.

Mínimo y máximo exactos de cada tipo entero de ancho fijo
TipoBitsMín. (decimal)Máx. (decimal)Máx. (hex)También llamado
int8 8 −128 127 0x7F C int8_t / signed char, Rust i8, Swift Int8
uint8 8 0 255 0xFF C uint8_t, Rust u8, Swift UInt8, Go byte
int16 16 −32 768 32 767 0x7FFF C short, Java short, Rust i16, Swift Int16
uint16 16 0 65 535 0xFFFF C unsigned short, Rust u16, Swift UInt16
int32 32 −2 147 483 648 2 147 483 647 0x7FFFFFFF C int, Java int, Rust i32, Swift Int32
uint32 32 0 4 294 967 295 0xFFFFFFFF C unsigned int, Rust u32, Swift UInt32
int64 64 −9 223 372 036 854 775 808 9 223 372 036 854 775 807 0x7FFFFFFFFFFFFFFF C long long, Java long, Rust i64, Swift Int (64-bit platforms)
uint64 64 0 18 446 744 073 709 551 615 0xFFFFFFFFFFFFFFFF C unsigned long long, Rust u64, Swift UInt (64-bit platforms)

2⁶³ y 2⁶⁴: los límites de 64 bits

Estos cinco valores aparecen constantemente en comprobaciones de desbordamiento, tipos de columna de bases de datos y errores del tipo «por qué mi contador es negativo»:

  • 2⁶³ = 9 223 372 036 854 775 808 = 0x8000000000000000 — uno más que el mayor valor de 64 bits con signo.
  • 2⁶³ − 1 = 9 223 372 036 854 775 807 = 0x7FFFFFFFFFFFFFFF — máximo de int64.
  • −2⁶³ = −9 223 372 036 854 775 808 — mínimo de int64; su patrón de 64 bits en complemento a dos es 0x8000000000000000.
  • 2⁶⁴ = 18 446 744 073 709 551 616 = 0x10000000000000000 — necesita 65 bits, así que no cabe en ningún tipo de 64 bits.
  • 2⁶⁴ − 1 = 18 446 744 073 709 551 615 = 0xFFFFFFFFFFFFFFFF — máximo de uint64; el mismo patrón se lee como −1 en int64.

Potencias de dos de 2⁰ a 2⁶⁴

Cada fila tiene enlace propio por exponente, por ejemplo /es/referencia/rangos-de-enteros/#2-63.

Potencias de dos de 2⁰ a 2⁶⁴, en decimal y hexadecimal
PotenciaDecimalHexNota
2⁰ 1 0x1
2¹ 2 0x2
2² 4 0x4
2³ 8 0x8
2⁴ 16 0x10
2⁵ 32 0x20
2⁶ 64 0x40
2⁷ 128 0x80 Máximo de int8 + 1
2⁸ 256 0x100 Un byte contiene 256 valores (0–255)
2⁹ 512 0x200
2¹⁰ 1 024 0x400 1 KiB
2¹¹ 2 048 0x800
2¹² 4 096 0x1000
2¹³ 8 192 0x2000
2¹⁴ 16 384 0x4000
2¹⁵ 32 768 0x8000 Máximo de int16 + 1
2¹⁶ 65 536 0x10000 64 KiB; máximo de uint16 + 1
2¹⁷ 131 072 0x20000
2¹⁸ 262 144 0x40000
2¹⁹ 524 288 0x80000
2²⁰ 1 048 576 0x100000 1 MiB
2²¹ 2 097 152 0x200000
2²² 4 194 304 0x400000
2²³ 8 388 608 0x800000
2²⁴ 16 777 216 0x1000000
2²⁵ 33 554 432 0x2000000
2²⁶ 67 108 864 0x4000000
2²⁷ 134 217 728 0x8000000
2²⁸ 268 435 456 0x10000000
2²⁹ 536 870 912 0x20000000
2³⁰ 1 073 741 824 0x40000000 1 GiB
2³¹ 2 147 483 648 0x80000000 Máximo de int32 + 1
2³² 4 294 967 296 0x100000000 Máximo de uint32 + 1
2³³ 8 589 934 592 0x200000000
2³⁴ 17 179 869 184 0x400000000
2³⁵ 34 359 738 368 0x800000000
2³⁶ 68 719 476 736 0x1000000000
2³⁷ 137 438 953 472 0x2000000000
2³⁸ 274 877 906 944 0x4000000000
2³⁹ 549 755 813 888 0x8000000000
2⁴⁰ 1 099 511 627 776 0x10000000000 1 TiB
2⁴¹ 2 199 023 255 552 0x20000000000
2⁴² 4 398 046 511 104 0x40000000000
2⁴³ 8 796 093 022 208 0x80000000000
2⁴⁴ 17 592 186 044 416 0x100000000000
2⁴⁵ 35 184 372 088 832 0x200000000000
2⁴⁶ 70 368 744 177 664 0x400000000000
2⁴⁷ 140 737 488 355 328 0x800000000000
2⁴⁸ 281 474 976 710 656 0x1000000000000
2⁴⁹ 562 949 953 421 312 0x2000000000000
2⁵⁰ 1 125 899 906 842 624 0x4000000000000
2⁵¹ 2 251 799 813 685 248 0x8000000000000
2⁵² 4 503 599 627 370 496 0x10000000000000
2⁵³ 9 007 199 254 740 992 0x20000000000000
2⁵⁴ 18 014 398 509 481 984 0x40000000000000
2⁵⁵ 36 028 797 018 963 968 0x80000000000000
2⁵⁶ 72 057 594 037 927 936 0x100000000000000
2⁵⁷ 144 115 188 075 855 872 0x200000000000000
2⁵⁸ 288 230 376 151 711 744 0x400000000000000
2⁵⁹ 576 460 752 303 423 488 0x800000000000000
2⁶⁰ 1 152 921 504 606 846 976 0x1000000000000000
2⁶¹ 2 305 843 009 213 693 952 0x2000000000000000
2⁶² 4 611 686 018 427 387 904 0x4000000000000000
2⁶³ 9 223 372 036 854 775 808 0x8000000000000000 Máximo de int64 + 1
2⁶⁴ 18 446 744 073 709 551 616 0x10000000000000000 Máximo de uint64 + 1

Desbordamiento: qué pasa al superar el límite

La aritmética de ancho fijo es modular: en 8 bits sin signo, 255 + 1 da la vuelta a 0, y en 8 bits con signo, 127 + 1 da la vuelta a −128, porque el acarreo que sale del bit más alto simplemente se descarta. Lo que hace cada lenguaje al respecto varía: C deja el desbordamiento con signo sin definir, Java da la vuelta en silencio, Swift aborta en tiempo de ejecución y Rust lanza un panic en compilaciones de depuración pero da la vuelta en las de producción. La calculadora de complemento a dos te deja ver el patrón de bits resultante para cualquier ancho, y la guía de complemento a dos explica por qué el rango es asimétrico.

Herramientas y guías relacionadas