Si las máquinas de 32 bits sólo pueden manejar números hasta 2^32, ¿por qué puedo escribir 1000000000000 (trillón) sin que mi máquina se caiga?

Respondo a tu pregunta preguntándote otra:

¿Cómo cuentas con los dedos hasta 6?

Probablemente cuentas hasta el mayor número posible con una mano, y luego pasas a la segunda mano cuando te quedas sin dedos. Los ordenadores hacen lo mismo, si necesitan representar un valor más grande que el que puede contener un solo registro utilizarán múltiples bloques de 32 bits para trabajar con los datos.

Tiene razón en que un número entero de 32 bits no puede contener un valor mayor de 2^32-1. Sin embargo, el valor de este entero de 32 bits y la forma en que aparece en su pantalla son dos cosas completamente diferentes. La cadena impresa “1000000000000” no está representada por un entero de 32 bits en la memoria.

Para mostrar literalmente el número “1000000000000” se necesitan 13 bytes de memoria. Cada byte individual puede contener un valor de hasta 255. Ninguno de ellos puede contener el valor numérico completo, pero interpretado individualmente como caracteres ASCII (por ejemplo, el carácter “0” se representa por el valor decimal 48, valor binario 00110000), pueden ser encadenados en un formato que tenga sentido para usted, un humano.

Un concepto relacionado en la programación es typecasting, que es la forma en que una computadora interpretará una corriente particular de 0s y 1s. Como en el ejemplo anterior, puede ser interpretado como un valor numérico, un carácter o incluso algo totalmente distinto. Mientras que un entero de 32 bits puede no ser capaz de mantener un valor de 1000000000000, un número de 32 bits en coma flotante sí podrá, usando una interpretación completamente diferente.

En cuanto a la forma en que las computadoras pueden trabajar y procesar grandes números internamente, existen enteros de 64 bits (que pueden acomodar valores de hasta 16 billones de billones), valores en coma flotante, así como bibliotecas especializadas que pueden trabajar con números arbitrariamente grandes.

En primer lugar, los ordenadores de 32 bits pueden almacenar números de hasta 2³²-1 en una sola palabra de máquina. La palabra de máquina ](https://en.wikipedia.org/wiki/Machine_word) es la cantidad de datos que la CPU puede procesar de forma natural (es decir, las operaciones con datos de ese tamaño se implementan en el hardware y generalmente son más rápidas de realizar). Las CPUs de 32 bits usan palabras que consisten en 32 bits, por lo que pueden almacenar números de 0 a 2³²-1 en una sola palabra.

En segundo lugar, 1 trillón y 1000000000000 son dos cosas diferentes.

• 1 trillón es un concepto abstracto de número
• 1000000000000 es texto

Al presionar 1 una vez y luego 0 12 veces estás escribiendo texto. 1 entrada 1, 0 entradas 0. ¿Veis? Estás escribiendo caracteres. Los caracteres no son números. Las máquinas de escribir no tenían ni CPU ni memoria y manejaban bastante bien esos “números”, porque es sólo texto.

Demuestra que 1000000000000 no es un número, sino texto: puede significar 1 billón (en decimal), 4096 (en binario) o 281474976710656 (en hexadecimal). Tiene aún más significados en diferentes sistemas. El significado de 1000000000000 es un número y almacenarlo es una historia diferente (volveremos a ello en un momento).

Para almacenar el texto (en programación se llama string) 1000000000000 se necesitan 14 bytes (uno por cada carácter más un byte NULL de terminación que básicamente significa “la cadena termina aquí”). Son 4 palabras de máquina. 3 y medio sería suficiente, pero como dije, las operaciones con palabras de máquina son las más rápidas. Supongamos que ASCII se utiliza para el almacenamiento de texto, por lo que en la memoria se verá así: (convirtiendo los códigos ASCII correspondientes a 0 y 1 a binario, cada palabra en una línea separada)

00110001 00110000 00110000 00110000
00110000 00110000 00110000 00110000
00110000 00110000 00110000 00110000
00110000 00000000 00000000 00000000

Cuatro caracteres caben en una palabra, el resto se mueve a la siguiente. El resto se mueve a la siguiente palabra hasta que todo (incluyendo el primer byte NULL) encaje.

Ahora, volvemos a almacenar números. Funciona igual que con el texto desbordante, pero se ajustan de derecha a izquierda. Puede parecer complicado, así que aquí hay un ejemplo. Para simplificar, asumamos que:

• nuestro ordenador imaginario utiliza decimal en lugar de binario
• un byte puede contener números 0..9
• una palabra consta de dos bytes

Aquí hay una memoria de 2 palabras vacía:

0 0
0 0

Guardemos el número 4:

0 4
0 0

Ahora sumemos 9:

1 3
0 0

Fíjense que ambos operandos cabrían en un byte, pero no el resultado. Pero tenemos otro listo para usar. Ahora almacenemos 99:

9 9
0 0

De nuevo, hemos usado el segundo byte para almacenar el número. Añadamos 1:

0 0
0 0

Whoops… Eso se llama desbordamiento de entero y es causa de muchos problemas serios, a veces muy caros.

Pero si esperamos que el desbordamiento ocurra, podemos hacer esto:

0 0
9 9

Y ahora agrega 1:

0 1
0 0

Se hace más claro si se eliminan los espacios de separación de bytes y las líneas nuevas:

0099 | +1
0100

Hemos predicho que el desbordamiento puede ocurrir y podemos necesitar memoria adicional. Manejar los números de esta manera no es tan rápido como con los números que caben en una sola palabra y tiene que ser implementado en el software. Añadir soporte para números de palabras de dos a 32 bits a un CPU de 32 bits lo convierte efectivamente en un CPU de 64 bits (ahora puede operar con números de 64 bits de forma nativa, ¿verdad?).

Todo lo que he descrito anteriormente se aplica a la memoria binaria con bytes de 8 bits y palabras de 4 bytes también, funciona más o menos de la misma manera:

00000000 00000000 00000000 00000000 11111111 11111111 11111111 11111111 | +1
00000000 00000000 00000000 00000001 00000000 00000000 00000000 00000000

Convertir tales números a sistema decimal es difícil, sin embargo. (pero funciona bastante bien con el hexadecimal )

Vous pouvez également écrire “CETTE DÉCLARATION EST FAUSSE” sans que votre ordinateur ne plante :) La réponse de Scott est parfaite pour certains cadres de calcul, mais votre question d’“écrire” un grand nombre implique que ce n'est que du texte simple, du moins jusqu'à ce qu'il soit interprété.

Edit: maintenant avec moins de sarcasme plus d'informations utiles sur les différentes façons dont un nombre peut être stocké en mémoire. Je vais les décrire avec une plus grande abstraction, c'est-à-dire en des termes dans lesquels un programmeur moderne peut écrire du code avant qu'il ne soit traduit en code machine pour être exécuté.

Les données d'un ordinateur doivent être limitées à un certain type, et une définition informatique de ce type décrit les opérations qui peuvent être effectuées sur ces données et comment (c'est-à-dire comparer des nombres, concaténer du texte ou XOR un booléen). Vous ne pouvez pas simplement ajouter du texte à un nombre, tout comme vous ne pouvez pas multiplier un nombre par du texte, de sorte que certaines de ces valeurs peuvent être converties entre types.

Commençons par les nombres entiers non signés. Dans ces types de valeurs, tous les bits sont utilisés pour stocker des informations sur les chiffres ; le vôtre est un exemple d'un 32-bit unsigned integer où toute valeur de 0 à 2^32-1 peut être stockée. Et oui, selon le langage ou l'architecture de la plate-forme utilisée, vous pourriez avoir des entiers de 16 bits ou de 256 bits.

Et si vous voulez obtenir des valeurs négatives ? Intuitivement, signed integers est le nom du jeu. La convention est d'attribuer toutes les valeurs de -2^(n-1) à 2^(n-1)-1 - de cette façon, nous évitons la confusion de devoir composer avec deux façons d'écrire +0 et -0. Ainsi, un entier signé de 32 bits contiendra une valeur de -2147483648 à 2147483647. Bien, n'est-ce pas ?

Ok, nous avons couvert les entiers qui sont des nombres sans composante décimale. Leur expression est plus délicate : la partie non entière ne peut raisonnablement se situer qu'entre 0 et 1, donc chaque bit supplémentaire utilisé pour la décrire augmenterait sa précision : ½, ¼, 1/8… Le problème est que vous ne pouvez pas exprimer avec précision une simple décimale 0.1 comme une somme de fractions qui ne peuvent avoir que des puissances de deux dans leur dénominateur ! Ne serait-il pas beaucoup plus facile de stocker le nombre comme un entier, mais d'accepter de mettre le point (décimal) à la place ? C'est ce qu'on appelle les nombres à point fixe, où on stocke 1234100 mais on se met d'accord sur une convention pour le lire comme 1234.100 à la place.

Un type relativement plus courant utilisé pour les calculs est floating point. Son fonctionnement est très soigné : il utilise un bit pour stocker la valeur du signe, puis un autre pour stocker l'exposant et le significand. Il existe des normes qui définissent de telles attributions, mais pour un 32-bit float le nombre maximum que vous pourriez stocker est un

(2 - 2^-23) * 2^(2^7 - 1) ≈ 3.4 * 10^38

Cela se fait toutefois au prix de la précision. Le JavaScript disponible dans les navigateurs utilise des flotteurs de 64 bits, et il ne peut toujours pas faire les choses correctement. Il suffit de le copier dans la barre d'adresse et d'appuyer sur la touche Entrée. Alerte spoiler : le résultat est non va être 0.3.

javascript:alert(0.1+0.2);

Il y a d'autres types d'alternatives comme les .NET 4.5 de Microsoft BigInteger , qui n'ont théoriquement pas de limites supérieures ou inférieures et doivent être calculés par “lots” ; mais peut-être les technologies les plus fascinantes sont celles qui comprennent les mathématiques, comme le moteur de Wolfram Mathematica, qui peut fonctionner précisément avec des valeurs abstraites comme infini .

La clave está en entender cómo las computadoras codifican los números.

Cierto, si una computadora insiste en almacenar los números usando una simple representación binaria del número con una sola palabra (4 bytes en un sistema de 32 bits), entonces una computadora de 32 bits sólo puede almacenar números hasta 2^32. Pero hay muchas otras maneras de codificar números dependiendo de lo que se quiera lograr con ellos.

Un ejemplo es la forma en que las computadoras almacenan números de punto flotante. Los ordenadores pueden utilizar un montón de formas diferentes para codificarlos. El estándar IEEE 754 define reglas para codificar números más grandes que 2^32. Crudamente, las computadoras pueden implementar esto dividiendo los 32 bits en diferentes partes que representan algunos dígitos del número y otros bits que representan el tamaño del número (es decir, el exponente, 10^x). Esto permite un rango mucho mayor de números en términos de tamaño, pero compromete la precisión (lo cual está bien para muchos propósitos). Por supuesto, la computadora también puede usar más de una palabra para esta codificación, aumentando la precisión de la magnitud de los números codificados disponibles. La versión simple decimal 32 del estándar IEEE permite números con unos 7 dígitos decimales de precisión y números de hasta aproximadamente 10^96 de magnitud.

Pero hay muchas otras opciones si se necesita la precisión extra. Obviamente puedes usar más palabras en tu codificación sin límite (aunque con una penalización de rendimiento para convertir en y fuera del formato codificado). Si quieres explorar una forma de hacerlo, hay un gran complemento de código abierto para Excel que utiliza un esquema de codificación que permite cientos de dígitos de precisión en el cálculo. El add-in se llama Xnumbers y está disponible aquí . El código está en Visual Basic que no es el más rápido posible pero tiene la ventaja de que es fácil de entender y modificar. Es una gran manera de aprender cómo los ordenadores consiguen codificar números más largos. Y puedes jugar con los resultados dentro de Excel sin tener que instalar ninguna herramienta de programación.

Todo está en tu pregunta.

Puedes escribir cualquier número que quieras en el papel. Intenta escribir un trillón de puntos en una hoja de papel blanco. Es lento e ineficaz. Por eso tenemos un sistema de 10 dígitos para representar esos grandes números. Incluso tenemos nombres para los grandes números como “millón”, “trillón” y más, para que no digas one one one one one one one one one one one... en voz alta.

Los procesadores de 32 bits están diseñados para trabajar de la forma más rápida y eficiente con bloques de memoria de exactamente 32 dígitos binarios. Pero nosotros, la gente, comúnmente usamos el sistema numérico de 10 dígitos, y las computadoras, al ser electrónicas, usan el sistema de 2 dígitos binario ). Los números 32 y 64 resultan ser potencias de 2. Así que un millón y un billón son potencias de 10. Es más fácil para nosotros operar con estos números que con multitudes de 65536, por ejemplo.

Dividimos los grandes números en dígitos cuando los escribimos en papel. Los ordenadores descomponen los números en un mayor número de dígitos. Podemos escribir cualquier número que queramos, y también lo pueden hacer los ordenadores si los diseñamos así.

32 y 64 bits se refieren a direcciones de memoria. La memoria de su ordenador es como los apartados de correos, cada uno tiene una dirección diferente. La CPU (Unidad Central de Procesamiento) utiliza esas direcciones para direccionar las ubicaciones de memoria en su RAM (Memoria de Acceso Aleatorio). Cuando la CPU sólo podía manejar direcciones de 16 bits, sólo podías usar 32mb de RAM (que parecía enorme en ese momento). Con 32bit se pasó a 4+gb (que parecía enorme en ese momento). Ahora que tenemos direcciones de 64 bits la RAM se convierte en terabytes (lo que parece enorme). Sin embargo el programa es capaz de asignar múltiples bloques de memoria para cosas como almacenar números y texto, eso depende del programa y no está relacionado con el tamaño de cada dirección. Así que un programa puede decirle a la CPU, voy a usar 10 bloques de direcciones de almacenamiento y luego almacenar un número muy grande, o una cadena de 10 letras o lo que sea. Nota al margen: Las direcciones de la memoria son apuntadas por “punteros”, por lo que el valor de 32 y 64 bits significa el tamaño del puntero usado para acceder a la memoria.

Porque la visualización del número se hace con caracteres individuales, no enteros. Cada dígito del número se representa con un literal de carácter separado, cuyo valor entero se define por la codificación que se está utilizando, por ejemplo 'a' se representa con el valor ascii 97, mientras que '1' se representa con 49. Revise la tabla de ascii aquí. Para visualizar tanto ‘a’ como ‘1’ es lo mismo. Son caracteres literales, no enteros. Cada carácter literal puede tener un valor máximo de 255 en una plataforma de 32 bits, almacenando el valor en un tamaño de 8 bits o 1 byte (Eso depende de la plataforma, sin embargo 8 bits es el tamaño de carácter más común), por lo que pueden agruparse y visualizarse. La cantidad de caracteres separados que pueden mostrarse depende de la memoria RAM que se tenga. Si tienes sólo 1 byte de RAM, entonces puedes mostrar sólo un carácter, si tienes 1 GB de RAM, puedes mostrar bien 102410241024 caracteres(Demasiado vago para hacer las matemáticas).

Esta limitación, sin embargo, se aplica a los cálculos, sin embargo supongo que estás interesado en el estándar IPV4. Aunque no está totalmente relacionado con los bit-size de los ordenadores, de alguna manera ha afectado a los estándares. Cuando se creó el estándar IPV4, almacenaron los valores ip en enteros de 32 bits. Ahora bien, una vez que le diste el tamaño, y se convirtió en estándar. Todo lo que sabemos de Internet dependía de eso, y luego nos quedamos sin direcciones IP para asignar. Así que si el estándar IP fue revisado para tener 64 bits, todo dejará de funcionar, incluyendo tu enrutador (asumo que esto es correcto) y otros dispositivos de red. Así que hay que crear un nuevo estándar, que acaba de cambiar el entero de 32 bits por uno de 128 bits. Y ajustar el resto del estándar. El fabricante de hardware sólo tiene que declarar que apoya este nuevo estándar y se convertirá en viral. Aunque no es tan simple, pero supongo que ya entendiste el punto aquí.

Disclaimer: La mayoría de los puntos mencionados aquí son fieles a mi suposición. Puede que haya pasado por alto puntos importantes aquí para hacerlo más simple. No soy bueno con los números, así que debo haberme perdido algunos dígitos, pero mi punto aquí es responder a la respuesta de la OP acerca de por qué no se bloquea el PC.

En los procesadores, hay “palabras”. Hay diferentes palabras. Cuando la gente dice “procesador de 32 bits”, se refieren principalmente a “ancho del bus de memoria”. Esta palabra consta de diferentes “campos”, que se refieren a los subsistemas de la computadora correspondientes a la transmisión (24 bits) y al control (otros bits). Puedo equivocarme en los números exactos, asegúrense de ello a través de los manuales.

Un aspecto completamente diferente es la computación. Los conjuntos de instrucciones SSE y MMX pueden almacenar números enteros largos. La longitud máxima sin pérdida de productividad depende de la versión actual de SSE pero siempre es un múltiplo de 64 bits.

Los procesadores actuales de Opteron pueden manejar números de 256 bits de ancho (no estoy seguro de los números enteros, pero sí de los flotantes).

Resumen : (1) el ancho del bus no está conectado al ancho de cálculo directamente, (2) incluso palabras diferentes (palabra de memoria, palabra de registro, palabra de bus, etc.) no están conectadas entre sí, de otra manera tienen un divisor común alrededor de 8 o 16 o 24. Muchos procesadores incluso utilizaron la palabra de 6 bits (pero su historia).

El propósito de un dispositivo de computación, generalmente, es aceptar, procesar, almacenar y emitir datos. El hardware subyacente es simplemente una máquina que ayuda a realizar esas cuatro funciones. No puede hacer ninguna de ellas sin software.

El software es el código que le dice a la máquina cómo aceptar datos, cómo procesarlos, cómo almacenarlos y cómo proporcionárselos a otros.

El hardware subyacente siempre tendrá limitaciones. En el caso de una máquina de 32 bits, la mayoría de los registros que procesan datos tienen sólo 32 bits de ancho. Sin embargo, esto no significa que la máquina no pueda manejar números más allá de 2^32, sino que si quiere manejar números más grandes, puede que la máquina tarde más de un ciclo en aceptarlos, procesarlos, almacenarlos o emitirlos.

El software le dice a la máquina cómo manejar los números. Si el software está diseñado para manejar números grandes, envía una serie de instrucciones a la CPU que le dicen cómo manejar los números más grandes. Por ejemplo, su número puede ser representado por dos registros de 32 bits. Si quisieras añadir 1.234 a tu número, el software le diría a la CPU que primero añada 1.234 al registro inferior, y luego compruebe el bit de desbordamiento para ver si esa adición dio como resultado un número demasiado grande para el registro inferior. Si lo hizo, entonces añade 1 al registro superior.

De la misma manera que a los niños de primaria se les enseña a sumar con la carga, se le puede decir a la CPU que maneje números más grandes de los que puede contener en un solo registro. Esto es cierto para la mayoría de las operaciones matemáticas genéricas, para números de cualquier tamaño práctico.

Las computadoras de 32 bits sólo pueden almacenar números hasta 2^32 en una sola palabra de máquina, pero eso no significa que no puedan manejar entidades de datos más grandes.

El significado de una computadora de 32 bits es generalmente que el bus de datos y el bus de direcciones tiene 32 bits de ancho, lo que significa que la computadora puede manejar 4 GB de espacio de direcciones de memoria a la vez, y enviar cuatro bytes de datos a la vez a través del bus de datos.

Eso, sin embargo, no limita a la computadora para manejar más datos, sólo tiene que dividir los datos en trozos de cuatro bytes cuando se envía a través del bus de datos.

El procesador normal de Intel de 32 bits puede manejar internamente números de 128 bits, lo que le permitiría manejar números como 100000000000000000000000000000000000000 sin ningún problema.

Puedes manejar números mucho más grandes que eso en un ordenador, pero entonces los cálculos tienen que ser hechos por software, la CPU no tiene instrucciones para manejar números más grandes que 128 bits. (Puede manejar números mucho más grandes en forma de números de punto flotante, pero entonces sólo tienes 15 dígitos de precisión).

Sólo agrego una nota a las muchas otras respuestas, porque este es un hecho bastante importante en esta pregunta que se ha pasado por alto.

“32 bits” se refiere al ancho de la dirección de la memoria. No tiene nada que ver con el tamaño del registro. Muchas CPUs de 32 bits probablemente tienen registros de 64 o incluso 128 bits. En particular, refiriéndose a la línea de productos x86, las recientes CPUs de consumo, que son todas de 64 bits, poseen hasta 256 registros de bits para propósitos especiales.

Esta diferencia entre el ancho de registro y el ancho de dirección ha existido desde la antigüedad, cuando teníamos registros de 4 bits y direcciones de 8 bits, o viceversa.

Es simple ver que almacenar un gran número no es un problema independientemente del tamaño del registro, como se explica en otras respuestas.

La razón por la que los registros, de cualquier tamaño que puedan ser, pueden adicionalmente también calcular con números más grandes, es que los cálculos demasiado grandes pueden ser desglosados en varios más pequeños que sí encajan en los registros (en realidad es un poco más complicado).

Las respuestas que ya se han dado son en realidad bastante buenas, pero tienden a abordar el tema desde diferentes lados y por lo tanto presentan un cuadro incompleto. También son un poco demasiado técnicas, en mi opinión.

Entonces, sólo para aclarar algo que se insinúa pero que no se expresa explícitamente en ninguna de las otras respuestas, y que creo que es el quid de la cuestión:

Estás mezclando varios conceptos en tu pregunta , y uno de ellos (“32 bit”) puede en realidad referirse a una variedad de cosas diferentes (y diferentes respuestas han asumido diferentes interpretaciones). Todos estos conceptos tienen algo que ver con el número de bits (1 y 0) utilizados (o disponibles) en diversos contextos informáticos (lo que quiero decir con esto se aclarará, espero, con los ejemplos siguientes), pero los conceptos son por lo demás no relacionados.

Explícitamente:

• “IPv4/6” se refiere al protocolo de Internet , un conjunto de reglas que definen cómo debe empaquetarse e interpretarse la información en Internet. La principal distinción (o al menos la más conocida) entre IPv4 e IPv6 es que el espacio de direcciones (es decir, el conjunto de direcciones que pueden utilizarse para distinguir entre diferentes lugares de la red) es mayor en IPv6. Esto tiene que ver con cuántos bits de cada paquete de datos enviado a través de la red se asignan para (es decir, se reservan con el propósito de) identificar al remitente del paquete y al destinatario previsto.
• Análogo no informático: Cada paquete es como una carta enviada por correo postal, y el espacio de la dirección es como la cantidad de caracteres que se “permite” usar al escribir la dirección y el remitente en el sobre.
• No veo que esto se mencione en ninguna de las otras respuestas hasta ahora.
• Las “palabras” de memoria de ordenador (32 y 64 bits) pueden considerarse generalmente como la pieza más pequeña de datos que un ordenador usa, o en la que “piensa”. Estos bits de datos se juntan para formar otros bits de datos, como trozos de texto o enteros más grandes.
• Analogía no computacional: las palabras pueden ser pensadas un poco como las letras que forman las palabras en el papel, o incluso como palabras individuales en un tren de pensamiento.
• Véase respuesta de Guffa , respuesta de sanaris , y el primer párrafo de respuesta de gronostaj .
• Los puntos de 32 bits pueden o no ser palabras, pero se tratan sin embargo atómicamente (es decir, como unidades individuales que no se pueden descomponer en componentes más pequeños). Los punteros son la forma más baja en que una computadora puede registrar la ubicación en la memoria de algún trozo de datos arbitrarios. Tenga en cuenta que el tamaño del puntero utilizado por la computadora (o, en realidad, por el sistema operativo) limita el rango de memoria al que puede acceder un solo puntero, ya que sólo hay tantas ubicaciones de memoria posibles a las que un puntero puede “apuntar” como valores posibles para el propio puntero. Esto es análogo a la forma en que IPv4 limita el rango de posibles direcciones de Internet, pero no limita la cantidad de datos que pueden estar presentes, por ejemplo, en una página web determinada. Sin embargo, el tamaño del puntero no limita el tamaño de los datos mismos a los que el puntero puede apuntar. (Para un ejemplo de un esquema para permitir que el tamaño de los datos exceda el rango del puntero, mira la estructura de puntero inode de Linux. Note que este es un uso ligeramente diferente de la palabra “puntero” que el típico, ya que puntero usualmente se refiere a un puntero en la memoria de acceso aleatorio, no en el espacio del disco duro)
• Analogía no computacional: hmmmm….esta es un poco difícil. ¿Quizás el sistema decimal Dewey para indexar materiales de biblioteca es un poco similar? O cualquier sistema de indexación, en realidad.
• Ver respuesta de SiteNook .
• Por favor, tenga en cuenta que mi explicación de los puntos anteriores elude algunos detalles sutiles y podría decirse que no es del todo correcta. Sin embargo, en los lenguajes de programación en los que los programadores trabajan directamente con los punteros, el modo mental que he dibujado suele ser suficiente para fines prácticos.
• Los números que un ordenador es “capaz de mostrar ” no están (para fines prácticos) limitados por el hardware o el sistema operativo del ordenador; se tratan como cualquier otro texto.
• Análogo no informático: escribir en un trozo de papel
• Ver respuesta del usuario1306322 y respuesta de Bigbio2002

Nota que esto no pretende ser una lista exhaustiva de interpretaciones de la frase “32 bit”

Crédito extra: para ver realmente la distinción filosófica básica entre los números y los trozos primitivos de la memoria del ordenador, leer un poco sobre Máquinas de Turing .

En tu mente sólo conoces 10 dígitos diferentes. Del 0 al 9. Internamente en tu cerebro, esto ciertamente se codifica de forma diferente a la de un ordenador.

Un ordenador utiliza bits para codificar los números, pero eso no es importante. Esa es la forma en que los ingenieros eligieron codificar las cosas, pero deberías ignorar eso. Puedes pensar en ello como si un ordenador de 32 bits tuviera una representación única de más de 4.000 millones de valores diferentes, mientras que nosotros los humanos tenemos una representación única para 10 valores diferentes.

Siempre que debemos comprender un número mayor, utilizamos un sistema. El número más a la izquierda es el más importante. Es 10 veces más importante que el siguiente.

Una computadora capaz de diferenciar entre cuatro mil millones de valores diferentes, tendrá que hacer que el valor más a la izquierda, en un conjunto de valores, sea cuatro mil millones de veces más importante que el siguiente valor en ese conjunto. En realidad a una computadora no le importa en absoluto. No le asigna “importancia” a los números. Los programadores deben hacer un código especial para cuidar de eso.

Cada vez que un valor se vuelve más grande que el número de símbolos únicos, 9 en una mente humana, se añade uno al número de la izquierda.

3+3=6

En este caso, el número todavía cabe dentro de una sola “ranura”

5+5=10. This situation is called an overflow.

Así que los humanos siempre se enfrentan al problema de no tener suficientes símbolos únicos. A menos que la computadora tenga un sistema para lidiar con esto, simplemente escribiría 0, olvidando que hay un número extra. Afortunadamente, las computadoras tienen una “bandera de desborde” que se levanta en este caso.

987+321 is more difficult.

Puede que hayas aprendido un método en la escuela. Un algoritmo. El algoritmo es bastante simple. Comienza sumando los dos símbolos más a la izquierda.

7+1=8, we now have ...8 as the result so far

Luego pasas a la siguiente ranura y realizas la misma adición.

8+2=10, the overflow flag is raised. We now have ...08, plus overflow.

Como tuvimos un desborde, significa que tenemos que sumar 1 al siguiente número.

9+3=12, and then we add one due to overflow. ...308, and we had another overflow.

No hay más números que sumar, así que simplemente creamos una ranura e insertamos 1 porque se levantó la bandera de desborde.

1308

Un ordenador lo hace exactamente de la misma manera, excepto que tiene 2^32 o incluso mejor 2^64 símbolos diferentes, en lugar de sólo 10 como los humanos.

A nivel de hardware, el ordenador trabaja en bits individuales usando exactamente el mismo método. Por suerte, eso se abstrae para los programadores. Los bits son sólo dos dígitos, porque es fácil de representar en una línea eléctrica. O bien la luz está encendida, o está apagada.

Finalmente, una computadora podría mostrar cualquier número como una simple secuencia de caracteres. Eso es lo que las computadoras son mejores. El algoritmo para convertir entre una secuencia de caracteres y una representación interna es bastante complejo.

En caso de que quiera un ejemplo práctico de cómo muchos programas en un sistema típico de Linux manejan el procesamiento y la salida de grandes números:

libgmp - La Biblioteca Aritmética de Precisión Múltiple GNU es la biblioteca más utilizada para este propósito en los sistemas Linux. Un ejemplo simple de multiplicar 2^80 por 1000:

#include <gmp.h>

// Each large integer uses the mpz_t type provided by libgmp
mpz_t a_large_number;
mpz_t base;
mpz_t result;

// Initalize each variable
mpz_init(a_large_number);
mpz_init(base);
mpz_init(result);

// Assign the number 2 to the variable |base|
mpz_set_ui(base, 2);

// Raise base^80 (2^80), store the result in |a_large_number|
mpz_pow_ui(a_large_number, base, 80);

// Multiply |a_large_number| by 1000, store the result in |result|
mpz_mul_ui(result, a_large_number, 1000);

// Finally, output the result in decimal and hex notation
gmp_printf("decimal: %Zd, hex: %ZX\n", result, result);

Así que básicamente es lo mismo que usar los operadores normales + - * /, sólo que con una biblioteca para dividir los números y almacenarlos internamente como números del tamaño de una palabra de una máquina múltiple (es decir, de 32 bits). También hay funciones de tipo scanf() para manejar la conversión de la entrada de texto a tipos enteros.

La estructura de mpz_t es exactamente como el ejemplo de Scott Chamberlain de contar hasta 6 usando dos manos. Es básicamente un conjunto de tipos mp_limb_t del tamaño de una palabra de máquina, y cuando un número es demasiado grande para caber en una palabra de máquina, GMP usa múltiples mp_limb_t para almacenar las partes altas/bajas del número.

Si escribes 1000000000000 por ejemplo en la calculadora, la computadora lo calculará como un número de Tipo real con punto decimal. El límite de 32 bits que mencionaste toca más todos los números de Tipo entero sin punto decimal. Diferentes tipos de datos usan diferentes métodos para llegar a los bits/bytes.

Números de tipo entero : Esta tabla podría ayudarte a captar el punto http://msdn.microsoft.com/en-us/library/296az74e.aspx ). Esto toca los límites para C++. Por ejemplo Número de tipo entero tiene límites desde -9223372036854775808 a 9223372036854775807.

Números de tipo real : Los números de tipo real contienen valor con punto flotante y exponente y se pueden introducir números mucho más grandes, pero con una precisión/precisión limitada. http://msdn.microsoft.com/en-us/library/6bs3y5ya.aspx ) Por ejemplo LDBL (doble grande) en C++ tiene un exponente máximo de 308, así que posiblemente se puede introducir o tener como resultado el número 9.999 x 10^308, significa que teóricamente tendrá 308(+1) dígitos de 9 pero sólo se usarán los 15 dígitos más importantes para representarlo, el resto se perderá, causa de una precisión limitada.

Además, hay diferentes lenguajes de programación y podrían tener diferentes implementaciones de los límites de los números. Por lo que se puede imaginar que las aplicaciones especializadas podrían manejar números mucho más grandes (y/o más exactos/precisos) que C++.

Porque no está mostrando un número (en lo que respecta al ordenador), sino una cadena , o una secuencia de dígitos. Claro, algunas aplicaciones (como la calculadora, supongo), que tratan con números, pueden manejar tal número, supongo. No sé qué trucos usan… Estoy seguro de que algunas de las otras respuestas más elaboradas cubren eso.

La mayor parte del contenido de esta respuesta provino originalmente de esta respuesta (escrito antes de que la otra pregunta fuera marcada como un duplicado). Así que discuto el uso de valores de 8 bits (aunque esta pregunta pregunta preguntaba sobre valores de 32 bits), pero eso está bien porque los valores de 8 bits son más sencillos de entender conceptualmente, y los mismos conceptos se aplican a valores más grandes como la aritmética de 32 bits.

Cuando sumas dos números que son de 8 bits, el número más grande que puedes obtener (0xFF + 0xFF = 1FE). De hecho, si multiplicas dos números que son de 8 bits, el mayor número que puedes obtener (0xFF * 0xFF = 0xFE01) sigue siendo 16 bits, dos veces de 8 bits.

Ahora, puedes estar asumiendo que un procesador de x-bits sólo puede llevar la cuenta de los x-bits. (Por ejemplo, un procesador de 8 bits sólo puede llevar la cuenta de 8 bits.) Eso no es exacto. El procesador de 8 bits recibe los datos en trozos de 8 bits. (Estos “trozos” suelen tener un término formal: una “palabra”. En un procesador de 8 bits, se utilizan palabras de 8 bits. En un procesador de 64 bits, se pueden utilizar palabras de 64 bits)

Por lo tanto, cuando le da a la computadora 3 bytes: Byte #1: La instrucción MUL Byte #2: los bytes de orden alto (por ejemplo, 0xA5) Byte #3: los bytes de orden bajo (por ejemplo, 0xCB) La computadora puede generar un resultado de más de 8 bits. La CPU puede generar resultados como este: 0100 0000 0100 0010 xxxx xxxx xxxx xxxx 1101 0111 también conocido como: 0x4082xxxxD7 Ahora, déjeme interpretarlo para usted: 0x sólo significa que los siguientes dígitos son hexadecimales.
Discutiré el “40” con más detalle momentáneamente. 82 es parte del registro “A”, que es una serie de 8 bits. xx y xx son parte de otros dos registros, llamados el registro “B” y el registro “C”. La razón por la que no llené esos bits con ceros o unos es que una instrucción “ADD” (enviada a la CPU) puede hacer que esos bits no sean modificados por la instrucción (mientras que la mayoría de los otros bits que utilizo en este ejemplo pueden ser alterados, excepto algunos de los bits de bandera). D7 cabría en más bits, llamados el registro “D”. Un registro es sólo un pedazo de memoria. Los registros están incorporados en las CPU, por lo que la CPU puede acceder a los registros sin necesidad de interactuar con la memoria de una memoria RAM.

Así que el resultado matemático de 0xA5 por 0xCB es 0x82D7.

Ahora, ¿por qué los bits se dividieron en los registros A y D en lugar de los registros A y B, o los registros C y D? Bueno, una vez más, este es un escenario de muestra que estoy usando, destinado a ser bastante similar en concepto a un lenguaje ensamblador real (Intel x86 16-bit, como el usado por el Intel 8080 y 8088 y muchas CPUs más nuevas). Podría haber algunas reglas comunes, como el registro “C” que se utiliza típicamente como índice para las operaciones de conteo (típico para los bucles), y el registro “B” que se utiliza para realizar un seguimiento de las compensaciones que ayudan a especificar las ubicaciones de la memoria. Por lo tanto, “A” y “D” pueden ser más comunes para algunas de las funciones aritméticas comunes.

Cada instrucción de la CPU debe tener alguna documentación, usada por la gente que programa en ensamblador. Esa documentación debería especificar qué registros son usados por cada instrucción. (Así que la elección sobre qué registros usar es a menudo especificada por los diseñadores de la CPU, no por los programadores del lenguaje ensamblador. Aunque, puede haber cierta flexibilidad)

Ahora, volviendo al “40” del ejemplo anterior: es una serie de bits, a menudo llamados “registro de banderas”. Cada bit del registro de banderas tiene un nombre. Por ejemplo, hay un bit de “desbordamiento” que la CPU puede establecer si el resultado es más grande que el espacio que puede almacenar un byte de los resultados. (El bit “desbordamiento” a menudo puede ser referido por el nombre abreviado de “OF”. Es una “o” mayúscula, no un cero). El software puede comprobar el valor de esta bandera y notar el “problema”. El trabajo con este bit es a menudo manejado de forma invisible por lenguajes de alto nivel, por lo que los programadores principiantes a menudo no aprenden a interactuar con las banderas de la CPU. Sin embargo, los programadores en ensamblador pueden acceder comúnmente a algunas de estas banderas de una manera muy similar a otras variables.

Por ejemplo, puede que tengas múltiples instrucciones ADD. Una instrucción ADD puede almacenar 16 bits de resultados en el registro A y en el registro D, mientras que otra instrucción puede almacenar los 8 bits bajos en el registro A, ignorar el registro D y especificar el bit de desbordamiento. Luego, más tarde (después de almacenar los resultados del registro A en la RAM principal), podría utilizar otra instrucción ADD que almacene sólo los 8 bits altos en un registro (posiblemente el registro A.) La necesidad de utilizar un indicador de desbordamiento puede depender de la instrucción de multiplicación que utilice.

(También suele haber una bandera de “underflow”, en caso de que restes demasiado para que quepa el resultado deseado)

Sólo para mostrarte lo complicadas que se pusieron las cosas: El Intel 4004 era una CPU de 4 bits El Intel 8008 era una CPU de 8 bits. Tenía registros de 8 bits llamados A, B, C y D. El Intel 8086 era una CPU de 16 bits. Tenía registros de 16 bits llamados AX, BX, CX, y DX. El Intel 80386 era una CPU de 32 bits. Tenía registros de 32 bits llamados EAX, EBX, ECX y EDX. Las CPUs Intel x64 tienen registros de 64 bits llamados RAX, RBX, RCX y RDX. Los chips x64 pueden ejecutar código de 16 bits (en algunos modos operativos), y pueden interpretar instrucciones de 16 bits. Al hacerlo, los bits que componen el registro AX son la mitad de los bits que componen el registro EAX, que son la mitad de los bits que componen el registro RAX. Así que cada vez que cambias el valor de AX, también estás cambiando EAX y RAX, porque esos bits usados por AX son parte de los bits usados por RAX. (Si cambias EAX por un valor que es un múltiplo de 65.536, entonces los 16 bits bajos no cambian, así que AX no cambiaría. Si cambias EAX por un valor que no es un múltiplo de 65.536, entonces eso también afectaría a AX)

Hay más banderas y registros que los que he mencionado. Simplemente elegí algunos de los más utilizados para dar un ejemplo conceptual simple.

Ahora, si estás en una CPU de 8 bits, cuando escribes en la memoria, puedes encontrar algunas restricciones acerca de poder referirte a una dirección de 8 bits, no a una dirección de 4 bits o 16 bits. Los detalles variarán en función de la CPU, pero si tiene tales restricciones, entonces la CPU puede estar tratando con palabras de 8 bits, por lo que la CPU se denomina más comúnmente “CPU de 8 bits”.