Als 32-bits machines slechts getallen tot 2^32 kunnen verwerken, waarom kan ik dan 1000000000000 (biljoen) schrijven zonder dat mijn machine crasht?

Ik beantwoord je vraag door je een andere vraag te stellen:

Hoe tel je op je vingers tot 6?

Je telt waarschijnlijk tot een zo groot mogelijk aantal met één hand, en dan ga je door naar je tweede hand als je geen vingers meer hebt. Computers doen hetzelfde, als ze een waarde moeten vertegenwoordigen die groter is dan een enkel register kan bevatten zullen ze meerdere 32bit blokken gebruiken om met de gegevens te werken.

U hebt gelijk dat een 32-bits geheel getal geen waarde groter dan 2^32-1 kan bevatten. De waarde van dit 32-bits gehele getal en hoe het op uw scherm verschijnt zijn echter twee totaal verschillende dingen. De afgedrukte string “1000000000000” wordt niet weergegeven door een 32-bits geheel getal in het geheugen.

Om het getal “1000000000000” letterlijk weer te geven heeft u 13 bytes geheugen nodig. Elke individuele byte kan een waarde van maximaal 255 bevatten. Geen van hen kan de volledige, numerieke waarde bevatten, maar individueel geïnterpreteerd als ASCII-tekens (bijvoorbeeld, het teken ‘0’ wordt weergegeven door de decimale waarde 48, binaire waarde 00110000), kunnen ze aan elkaar geregen worden tot een formaat dat zinvol is voor u, een mens.

• *

Een gerelateerd concept in de programmering is typecasting, dat is hoe een computer een bepaalde stroom van 0‘s en 1’s zal interpreteren. Net als in het bovenstaande voorbeeld kan het worden geïnterpreteerd als een numerieke waarde, een teken of zelfs iets anders. Terwijl een 32-bits geheel getal misschien geen waarde van 1000000000000 kan bevatten, zal een 32-bits drijfpuntnummer dat wel kunnen, met een geheel andere interpretatie.

Wat betreft de manier waarop computers intern kunnen werken met en verwerken van grote getallen, bestaan er 64-bits gehele getallen (die waarden tot 16 miljard kunnen bevatten), drijfpunt-waarden, maar ook gespecialiseerde bibliotheken die met willekeurig grote getallen kunnen werken.

Eerst en vooral kunnen 32-bits computers nummers tot 2³²-1 ** in één enkel machinewoord** opslaan. Machinewoord ](https://en.wikipedia.org/wiki/Machine_word) is de hoeveelheid gegevens die de CPU op een natuurlijke manier kan verwerken (d.w.z. bewerkingen op gegevens van die grootte worden geïmplementeerd in hardware en zijn over het algemeen het snelst uit te voeren). 32-bits CPU’s gebruiken woorden die bestaan uit 32 bits, dus ze kunnen getallen van 0 tot 2³²-1 in één woord opslaan.

Ten tweede, 1 biljoen en 1000000000000 zijn twee verschillende dingen.

• 1 biljoen is een abstract begrip van getal
• 1000000000000 is tekst

Door 1 keer te drukken en dan 12 keer op 0 te drukken, typ je tekst. 1 invoer 1, 0 invoer 0. Zie je? Je bent karakters aan het typen. Tekens zijn geen getallen. Schrijfmachines hadden helemaal geen CPU of geheugen en ze gingen vrij goed om met zulke “getallen”, omdat het gewoon tekst is.

Bewijs dat 1000000000000 geen getal is, maar tekst: het kan 1 biljoen (in decimaal), 4096 (in binair) of 281474976710656 (in hexadecimaal) betekenen. Het heeft nog meer betekenissen in verschillende systemen. Betekenis van 1000000000000 is een getal en het opslaan ervan is een ander verhaal (we komen er zo op terug).

Om de tekst op te slaan (in de programmering heet het string) 100000000000000 heb je 14 bytes nodig (één voor elk karakter plus een afsluitende NULL byte die in principe “de string eindigt hier” betekent). Dat zijn 4 machine-woorden. 3 en de helft zou genoeg zijn, maar zoals ik al zei, operaties op machine woorden zijn het snelst. Laten we aannemen dat ASCII wordt gebruikt voor tekstopslag, dus in het geheugen zal het er zo uitzien: (het omzetten van ASCII-codes die overeenkomen met 0 en 1 naar binair, elk woord in een aparte regel)

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

Vier tekens passen in één woord, de rest wordt verplaatst naar het volgende. De rest wordt verplaatst naar het volgende woord totdat alles (inclusief de eerste NULL-byte) past.

Nu, terug naar het opslaan van getallen. Het werkt net als bij overlopende tekst, maar ze passen van rechts naar links. Het klinkt misschien ingewikkeld, dus hier is een voorbeeld. Laten we voor de eenvoud aannemen dat:

• onze denkbeeldige computer gebruikt decimaal in plaats van binair
• één byte kan getallen bevatten 0..9
• één woord bestaat uit twee bytes

Hier is een leeg 2-word geheugen:

0 0
0 0

Laten we het nummer 4 opslaan:

0 4
0 0

Laten we nu 9 toevoegen:

1 3
0 0

Merk op dat beide operanden in één byte zouden passen, maar niet het resultaat. Maar we hebben een andere klaar voor gebruik. Laten we nu 99:

9 9
0 0

opslaan. We hebben opnieuw een tweede byte gebruikt om het nummer op te slaan. Laten we er 1 toevoegen:

0 0
0 0

Whoops… Dat heet integer overflow en is een oorzaak van veel ernstige problemen, soms zeer dure .

Maar als we verwachten dat er overflow zal plaatsvinden, kunnen we dit doen:

0 0
9 9

En voeg nu 1 toe:

0 1
0 0

Het wordt duidelijker als je byte-scheidende ruimtes en nieuwe lijnen verwijdert:

0099 | +1
0100

We hebben voorspeld dat er overflow kan plaatsvinden en dat we misschien extra geheugen nodig hebben. Het omgaan met getallen is op deze manier niet zo snel als met getallen die in enkele woorden passen en het moet in software worden geïmplementeerd. Het toevoegen van ondersteuning voor twee-32-bit-werknummers aan een 32-bit CPU maakt het effectief een 64-bit CPU (nu kan het op 64-bit getallen werken, toch?).

Alles wat ik hierboven heb beschreven is van toepassing op binair geheugen met 8-bit bytes en 4-byte woorden, het werkt ongeveer hetzelfde:

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

Het omzetten van zulke getallen naar een decimaal systeem is echter lastig. (maar het werkt werkt vrij goed met hexadecimale )

U kunt ook “DEZE VERKLARING IS VALS” schrijven zonder dat uw computer crasht :) @Scott’s antwoord is spot-on voor bepaalde rekenframeworks, maar je vraag om een groot aantal te “schrijven” impliceert dat het gewoon platte tekst is, tenminste totdat het geïnterpreteerd wordt.

Edit: nu met minder sarcasme~ meer bruikbare informatie over verschillende manieren waarop een nummer in het geheugen kan worden opgeslagen. Ik zal deze beschrijven met hoge abstractie, d.w.z. in termen dat een moderne programmeur code kan schrijven voordat deze wordt vertaald naar machine code voor uitvoering.

Gegevens op een computer moeten worden beperkt tot een bepaald type, en een computer definitie van zo'n type beschrijft welke bewerkingen kunnen worden uitgevoerd op deze gegevens en hoe (d.w.z. getallen vergelijken, aaneengeschakelde tekst of XOR een booleaanse). Je kunt niet zomaar tekst toevoegen aan een getal, net zoals je een getal niet kunt vermenigvuldigen met tekst, zodat sommige van deze waarden kunnen worden geconverteerd tussen typen.

Laten we beginnen met ongetekende gehele getallen. In deze waardetypes worden alle bits gebruikt om informatie over cijfers op te slaan; die van u is een voorbeeld van een 32-bit unsigned integer waar elke waarde van 0 tot 2^32-1 kan worden opgeslagen. En ja, afhankelijk van de taal of architectuur van het gebruikte platform zou je 16-bits gehele getallen of 256-bits gehele getallen kunnen hebben.

Wat als je negatief wilt worden? Intuïtief, gesigneerde gehele getallen is de naam van het spel. De conventie is om alle waarden van -2^(n-1) tot 2^(n-1)-1 toe te wijzen - op deze manier vermijden we de verwarring van het moeten omgaan met twee manieren om +0 en -0 te schrijven. Dus een 32-bit gesigneerd geheel getal zou een waarde van -2147483648 tot 2147483647 bevatten. Netjes, is het niet?

Ok, we hebben getallen zonder decimale komponent behandeld. Het uitdrukken van deze getallen is lastiger: het niet-integrale deel kan verstandig alleen ergens tussen 0 en 1 liggen, dus elk extra beetje dat gebruikt wordt om het te beschrijven zou de precisie verhogen: ½, ¼, 1/8… Het probleem is dat je een simpel decimaal 0.1 niet precies kunt uitdrukken als een som van breuken die alleen maar krachten van twee in hun noemer kan hebben! Zou het niet veel gemakkelijker zijn om het getal als een geheel getal op te slaan, maar ga akkoord met het plaatsen van de radix (decimaal) punt in plaats daarvan? Dit heet vaste puntgetallen, waarbij we 1234100 opslaan, maar overeenkomen om het in plaats daarvan als 1234.100 te lezen.

Een relatief meer voorkomend type dat voor berekeningen wordt gebruikt is floating point. De manier waarop het werkt is echt netjes, het gebruikt een bit om de tekenwaarde op te slaan, dan wat om de exponent en significantie op te slaan. Er zijn standaarden die dergelijke toewijzingen definiëren, maar voor een 32-bit float is het maximum aantal dat je zou kunnen opslaan een overweldigende

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

Dit gaat echter ten koste van de precisie. JavaScript dat beschikbaar is in browsers gebruikt 64-bits floats, en het kan nog steeds niet goed werken. Kopieer dit gewoon in de adresbalk en druk op enter. Spoiler alert: het resultaat is niet gaat 0.3 worden.

javascript:alert(0.1+0.2);

Er zijn meer alternatieve types zoals Microsoft .NET 4.5’s BigInteger , die theoretisch geen boven- of ondergrenzen heeft en in “batches” berekend moet worden; maar misschien zijn de meer fascinerende technologieën die onderstaan wiskunde, zoals Wolfram Mathematica engine, die precies kan werken met abstracte waarden zoals oneindig .

De sleutel is te begrijpen hoe computers encode nummers.

Waar, als een computer aandringt op het opslaan van nummers met behulp van een eenvoudige binaire representatie van het nummer met behulp van een enkel woord (4 bytes op een 32-bits systeem), dan kan een 32-bits computer slechts nummers opslaan tot 2^32. Maar er zijn genoeg andere manieren om getallen te coderen, afhankelijk van wat je ermee wilt bereiken.

Een voorbeeld is hoe computers zwevende getallen opslaan. Computers kunnen een heleboel verschillende manieren gebruiken om ze te coderen. De standaard IEEE 754 definieert regels voor het coderen van getallen groter dan 2^32. In feite kunnen computers dit implementeren door de 32 bits te verdelen in verschillende delen die enkele cijfers van het getal vertegenwoordigen en andere bits die de grootte van het getal vertegenwoordigen (d.w.z. de exponent, 10^x). Dit laat een veel grotere range van getallen toe in termen van grootte, maar compromitteert de precisie (die voor vele doeleinden OK is). Natuurlijk kan de computer ook meer dan één woord gebruiken voor deze codering om de precisie van de grootte van de beschikbare gecodeerde getallen te verhogen. De eenvoudige decimale 32-versie van de IEEE-standaard laat getallen toe met ongeveer 7 decimale cijfers van de precisie en getallen tot ongeveer 10^96 in de magnitude.

Maar er zijn vele andere opties als je de extra precisie nodig hebt. Uiteraard kunt u meer woorden gebruiken in uw codering zonder limiet (wel met een prestatieboete om te converteren naar en uit het gecodeerde formaat). Als u een manier wilt verkennen om dit te doen is er een geweldige open-source add-in voor Excel die gebruik maakt van een coderingsschema dat honderden cijfers van precisie in de berekening toelaat. De add-in heet Xnumbers en is beschikbaar hier . De code staat in Visual Basic, wat niet de snelst mogelijke is, maar heeft het voordeel dat het gemakkelijk te begrijpen en te wijzigen is. Het is een geweldige manier om te leren hoe computers langere getallen kunnen coderen. En u kunt met de resultaten binnen Excel spelen zonder dat u programmeertools hoeft te installeren.

Het staat allemaal in je vraag.

Je kunt elk nummer dat je wilt op papier _schrijven. Probeer eens een biljoen stippen te schrijven op een wit vel papier. Het is langzaam en ineffectief. Daarom hebben we een 10-cijferig systeem om die grote getallen weer te geven. We hebben zelfs namen voor grote getallen zoals “miljoen”, “triljoen” en meer, dus je zegt one one one one one one one one one one one... niet hardop.

32-bits processoren zijn ontworpen om zo snel en efficiënt mogelijk te werken met blokken geheugen die precies 32 binaire cijfers lang zijn. Maar wij, mensen, gebruiken meestal een 10-cijferig numeriek systeem, en computers, die elektronisch zijn, gebruiken een 2-cijferig systeem binair ). De getallen 32 en 64 zijn toevallig gewoon 2. Een miljoen en een biljoen zijn dus 10. Het is makkelijker voor ons om met deze getallen te werken dan bijvoorbeeld met massa’s van 65536.

We breken grote getallen op in cijfers als we ze op papier schrijven. Computers splitsen getallen op in een groter aantal cijfers. We kunnen elk getal dat we willen opschrijven, en dat geldt ook voor de computers als we ze zo ontwerpen.

32bit en 64bit verwijzen naar geheugenadressen. Uw computergeheugen is als een postbus, elk heeft een ander adres. De CPU (Central Processing Unit) gebruikt deze adressen om geheugenlocaties op uw RAM (Random Access Memory) te adresseren. Wanneer de CPU slechts 16bit adressen kon verwerken, kon u slechts 32mb RAM gebruiken (wat op dat moment enorm leek). Met 32bit ging het naar 4+gb (wat toen enorm leek). Nu we 64bit adressen hebben gaat het RAM in terabytes (wat enorm lijkt). Het programma is echter in staat om meerdere blokken geheugen toe te wijzen voor zaken als het opslaan van nummers en tekst, dat is aan het programma en niet gerelateerd aan de grootte van elk adres. Dus een programma kan de CPU vertellen, ik ga 10 adresblokken van opslag gebruiken en dan een zeer groot aantal, of een 10-letter string of wat dan ook, opslaan. Kanttekening: Geheugenadressen worden aangeduid door “pointers”, dus de 32- en 64-bits waarde betekent de grootte van de aanwijzer die wordt gebruikt om toegang te krijgen tot het geheugen.

Perché la visualizzazione del numero è fatta usando caratteri singoli, non interi. Ogni cifra del numero è rappresentata con un carattere letterale separato, il cui valore intero è definito dalla codifica utilizzata, ad esempio 'a' è rappresentato con il valore ascii 97, mentre '1' è rappresentato con 49. Controllare la tabella ascii qui . Per visualizzare sia ‘a’ che ‘1’ è uguale. Sono caratteri letterali, non interi. Ogni carattere letterale può avere un valore massimo di 255 in una piattaforma a 32 bit che memorizza il valore in 8 bit o 1 byte (che dipende dalla piattaforma, tuttavia 8 bit è la dimensione del carattere più comune), quindi possono essere raggruppati insieme e possono essere visualizzati. La quantità di caratteri separati che possono essere visualizzati dipende dalla RAM che si ha a disposizione. Se si dispone di 1 solo byte di RAM allora si può visualizzare un solo carattere, se si dispone di 1GB di RAM, si possono visualizzare bene 1024*1024*1024 caratteri(Troppo pigri per fare i conti).

Questa limitazione si applica comunque ai calcoli, tuttavia credo che siate interessati allo standard IPV4. Anche se non è interamente correlato al bit-size dei computer, in qualche modo ha influito sugli standard. Quando lo standard IPV4 è stato creato, i valori ip sono stati memorizzati in numeri interi a 32 bit. Ora, una volta data la dimensione, è diventato standard. Tutto ciò che sappiamo di internet dipendeva da questo, e poi abbiamo finito gli indirizzi IP da assegnare. Quindi, se lo standard IP è stato rivisto per avere 64 bit, tutto ha smesso di funzionare, compreso il router (presumo che questo sia corretto) e gli altri dispositivi di rete. Quindi è necessario creare un nuovo standard, che ha appena sostituito il 32 bit intero con uno a 128 bit. E regolato il resto dello standard. Il produttore di hardware deve solo dichiarare che supporta questo nuovo standard e diventerà virale. Anche se non è così semplice, ma credo che il punto sia chiaro.

Disclaimer: La maggior parte dei punti menzionati qui sono fedeli alla mia supposizione. Potrei aver tralasciato dei punti importanti per semplificare le cose. Non sono bravo con i numeri, così deve aver perso alcune cifre, ma il mio punto qui è quello di rispondere alla risposta dell'OP sul perché non si bloccherà il PC.

In processors zijn er “woorden”. Er zijn verschillende woorden. Als mensen zeggen “32 bit processor”, bedoelen ze meestal “geheugenbusbreedte”. Dit woord bestaat uit verschillende “velden”, die verwijzen naar subsystemen van de computer die overeenkomen met zenden (24 bits) en besturen (andere bits). Ik kan me vergissen in exacte getallen, zorg ervoor dat je het zeker weet door middel van handleidingen.

Compleet ander aspect is de berekening. SSE en MMX instructiesets kunnen lange gehele getallen opslaan. Maximale lengte zonder productiviteitsverlies is afhankelijk van de huidige SSE-versie, maar het gaat altijd om een veelvoud van 64 bits.

Huidige Opteron-processoren kunnen 256 bit brede getallen aan (ik ben niet zeker van gehele getallen, maar float is zeker).

Samenvatting : (1) busbreedte is niet direct verbonden met rekenbreedte, (2) zelfs verschillende woorden (geheugenwoord, registerwoord, buswoord etc) zijn niet met elkaar verbonden, anders hebben ze een gemeenschappelijke deler over 8 of 16 of 24. Veel processoren gebruikten zelfs 6-bits woord (maar de geschiedenis ervan).

Het doel van een computerapparaat is over het algemeen om gegevens te accepteren, te verwerken, op te slaan en uit te zenden. De onderliggende hardware is slechts een machine die helpt bij het uitvoeren van deze vier functies. Het kan geen van deze functies uitvoeren zonder software.

Software is de code die de machine vertelt hoe de gegevens te accepteren, te verwerken, op te slaan en te verstrekken aan anderen.

De onderliggende hardware zal altijd beperkingen hebben. In het geval van een 32 bit machine zijn de meeste registers die gegevens verwerken slechts 32 bits breed. Dit betekent echter niet dat de machine niet meer dan 2^32 getallen kan verwerken, het betekent dat als je met grotere getallen wilt omgaan, de machine meer dan één cyclus nodig heeft om het te accepteren, te verwerken, op te slaan of uit te zenden.

De software vertelt de machine hoe ze met getallen om moet gaan. Als de software is ontworpen om met grote aantallen om te gaan, stuurt het een serie instructies naar de CPU die het vertelt hoe met de grotere aantallen om te gaan. Zo kan je nummer bijvoorbeeld worden weergegeven door twee 32-bits registers. Als u 1.234 aan uw nummer wilt toevoegen, vertelt de software de CPU om eerst 1.234 aan het onderste register toe te voegen en vervolgens de overloopbit te controleren om te zien of die toevoeging resulteerde in een getal dat te groot is voor het onderste register. Als dat het geval is, dan voegt het 1 toe aan het bovenste register.

Op dezelfde manier waarop basisschoolkinderen geleerd wordt om met carry toe te voegen, kan de CPU verteld worden om met getallen om te gaan die groter zijn dan het in een enkel register kan bevatten. Dit geldt voor de meeste generieke wiskundige bewerkingen, voor getallen van elke praktische omvang.

32 bit computers kunnen slechts getallen tot 2^32 in een enkel machinewoord opslaan, maar dat betekent niet dat ze geen grotere entiteiten van gegevens kunnen verwerken.

De betekenis van een 32 bit computer is over het algemeen dat de databus en de adresbus 32 bits breed zijn, wat betekent dat de computer 4 GB geheugenadresruimte in één keer kan verwerken en vier bytes aan gegevens tegelijk over de databus kan verzenden.

Dat beperkt de computer echter niet tot het verwerken van meer data, het hoeft alleen maar de data in vier bytes te verdelen wanneer het over de databus wordt verzonden.

De gewone Intel 32-bits processor kan 128-bits nummers intern verwerken, waardoor je nummers als 1000000000000000000000000000000 zonder enig probleem kunt verwerken.

U kunt veel grotere getallen verwerken dan die in een computer, maar dan moeten de berekeningen door software worden gedaan, de CPU heeft geen instructies voor het verwerken van getallen groter dan 128 bits. (Het kan veel grotere getallen in de vorm van drijvende kommagetallen aan, maar dan heb je slechts 15 cijfers aan precisie).

Ik voeg alleen een noot toe aan de vele andere antwoorden, omdat dit een vrij belangrijk gegeven is in deze vraag die gemist is.

“32 bit” verwijst naar de geheugenadresbreedte. Het heeft niets te maken met de grootte van het register. Veel 32 bit CPU’s hebben waarschijnlijk 64 of zelfs 128 bit registers. In het bijzonder verwijzend naar de x86 productlijn, de recente consumenten-CPU’s, die allemaal 64 bit zijn, hebben tot 256 bit registers voor speciale doeleinden.

Dit verschil tussen de registerbreedte en de adresbreedte bestaat al sinds de oudheid, toen we nog 4 bit registers en 8 bit adressen hadden, of andersom.

Het is eenvoudig te zien dat het opslaan van een groot aantal registers geen probleem is, ongeacht de grootte van het register, zoals uitgelegd in andere antwoorden.

De reden waarom de registers, van welke grootte ze ook mogen zijn, ook berekenen met grotere aantallen, is dat te grote berekeningen kunnen worden opgesplitst in verschillende kleinere die wel in de registers passen (het is in werkelijkheid net iets gecompliceerder).

De antwoorden die al gegeven zijn, zijn eigenlijk vrij goed, maar ze hebben de neiging om de kwestie van verschillende kanten aan te pakken en geven dus een onvolledig beeld. Ze zijn ook een beetje te technisch, naar mijn mening.

Dus, om iets te verduidelijken dat wel gesuggereerd maar niet expliciet verwoord is in een van de andere antwoorden, en waarvan ik denk dat het de kern van de zaak is:

Je haalt verschillende concepten door elkaar in je vraag , en een ervan (“32 bit”) kan eigenlijk naar verschillende dingen verwijzen (en verschillende antwoorden hebben verschillende interpretaties verondersteld). Deze concepten hebben allemaal iets te maken met het aantal bits (1 en 0) dat wordt gebruikt (of beschikbaar is) in verschillende computercontexten (wat ik hiermee bedoel wordt hopelijk verduidelijkt door de voorbeelden hieronder), maar de concepten zijn anderzijds ongerelateerd.

Expliciet:

• “IPv4/6” verwijst naar internetprotocol , een set regels die bepalen hoe informatie op het internet moet worden verpakt en geïnterpreteerd. Het primaire (of in ieder geval het meest bekende) onderscheid tussen IPv4 en IPv6 is dat de adresruimte (d.w.z. de set adressen die kan worden gebruikt om onderscheid te maken tussen verschillende locaties op het netwerk) groter is in IPv6. Dit heeft te maken met het aantal bits in elk pakket van gegevens dat over het netwerk wordt verzonden, die toegewezen worden voor (d.w.z. opzij worden gezet ten behoeve van) het identificeren van de afzender van het pakket en de beoogde ontvanger.
• Non-computing analogie: Elk pakket is als een brief verzonden via slakkenpost, en de adresruimte is als de hoeveelheid karakters die je “mag” gebruiken bij het schrijven van het adres en het retouradres op de envelop.
• Ik zie dit niet in een van de andere antwoorden tot nu toe.
• Computergeheugen “woorden” (32-bit en 64-bit) kunnen over het algemeen worden gezien als het kleinste stukje data dat een computer gebruikt, of “denkt” in. Deze stukjes data komen samen om andere stukjes data te vormen, zoals brokken tekst of grotere gehele getallen.
• Non-computing analogy: woorden kunnen worden gezien als een beetje zoals letters die woorden op papier vormen, of zelfs als individuele woorden in een gedachtengang.
• Zie Guffa’s antwoord , sanaris antwoord , en de eerste paragraaf van gronostaj antwoord .
• 32-bits pointers kunnen al dan niet woorden zijn, maar ze worden desondanks atomisch behandeld (d.w.z. als afzonderlijke eenheden die niet kunnen worden opgesplitst in kleinere componenten). Pointers zijn de laagst mogelijke manier waarop een computer de locatie in het geheugen van een willekeurig stuk data kan vastleggen. Merk op dat de grootte van de aanwijzer die door de computer (of eigenlijk door het besturingssysteem) wordt gebruikt, het bereik van het geheugen dat door een enkele aanwijzer kan worden benaderd beperkt, aangezien er slechts zoveel mogelijke geheugenlocaties zijn waar een aanwijzer naar kan “wijzen” als er mogelijke waarden voor de aanwijzer zelf zijn. Dit is analoog aan de manier waarop IPv4 het bereik van mogelijke internetadressen beperkt, maar beperkt niet de hoeveelheid data die in bijvoorbeeld een bepaalde webpagina aanwezig kan zijn. De grootte van de pointer beperkt echter not de grootte van de gegevens zelf waarnaar de pointer kan verwijzen. (Voor een voorbeeld van een schema om toe te staan dat de gegevensgrootte het bereik van de aanwijzer overschrijdt, kijkt u naar de inode pointer structuur van Linux. Merk op dat dit een iets ander gebruik is van het woord “pointer” dan typisch is, aangezien pointer meestal verwijst naar een pointer in het random access geheugen, niet naar de ruimte op de harde schijf.)
• Non-computing analogie: hmmmm….dit is een beetje lastig. Misschien is het Dewey decimale systeem voor het indexeren van bibliotheekmateriaal een beetje vergelijkbaar? Of een willekeurig indexeringssysteem, echt waar.
• Zie SiteNook’s antwoord .
• Merk op dat mijn uitleg van de aanwijzingen hierboven enkele subtiele details overstijgt en misschien niet helemaal juist is. In programmeertalen waarin programmeurs direct met pointers werken, is de mentale modus die ik heb getekend echter meestal voldoende voor praktische doeleinden.
• De getallen die een computer “kan weergeven ” worden niet (voor praktische doeleinden) beperkt door de hardware of het besturingssysteem van de computer; ze worden behandeld zoals elke andere tekst.
• Niet-computerende analogie: schrijven op een stuk papier
• Zie user1306322’s antwoord en Bigbio2002’s antwoord

Merk op dat dit niet bedoeld is als een uitgebreide lijst met interpretaties voor de zinsnede “32 bit.”

Extra troef: om het filosofische onderscheid tussen getallen en primitieve brokken computergeheugen echt te zien, lees een beetje over Turing machines .

In je hoofd ken je maar 10 verschillende cijfers. 0 tot 9. Intern in je hersenen is dit zeker anders gecodeerd dan in een computer.

Een computer gebruikt bits om nummers te coderen, maar dat is niet belangrijk. Dat is gewoon de manier waarop ingenieurs ervoor gekozen hebben om dingen te coderen, maar dat moet je negeren. Je kunt het zien als een 32 bit computer heeft een unieke representatie van meer dan 4 miljard verschillende waarden, terwijl wij mensen een unieke representatie hebben voor 10 verschillende waarden.

Als we een groter getal moeten begrijpen, gebruiken we een systeem. Het meest linkse getal is het belangrijkste. Het is 10 keer belangrijker dan de volgende.

Een computer die in staat is om vier miljard verschillende waarden te onderscheiden, zal op dezelfde manier de meest linkse waarde, in een set van waarden, vier miljard keer zo belangrijk moeten maken als de volgende waarde in die set. Eigenlijk kan het een computer helemaal niets schelen. Hij kent geen “belang” toe aan getallen. Programmeurs moeten daarvoor speciale code maken.

Wanneer een waarde groter wordt dan het aantal unieke symbolen, 9 in een mensengeest, tel je één op bij het getal links.

3+3=6

In dit geval past het getal nog steeds in één “slot”

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

Dus mensen gaan altijd om met het probleem van het niet hebben van voldoende unieke symbolen. Tenzij de computer een systeem heeft om dit aan te pakken, zou hij gewoon 0 schrijven, waarbij hij vergeet dat er een extra nummer is. Gelukkig hebben computers een “overloopvlag” die in dit geval wordt gehesen.

987+321 is more difficult.

Je hebt misschien een methode geleerd op school. Een algoritme. Het algoritme is vrij eenvoudig. Begin met het toevoegen van de twee meest linkse symbolen.

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

Dan ga je naar het volgende slot en voer je dezelfde toevoeging uit.

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

Aangezien we een overloopvlag hadden, betekent dit dat we 1 moeten toevoegen aan het volgende nummer.

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

Er zijn geen getallen meer toe te voegen, dus we maken gewoon een slot en voegen 1 in omdat de overloopvlag gehesen is.

1308

Een computer doet het op precies dezelfde manier, behalve dat hij 2^32 of nog beter 2^64 verschillende symbolen heeft, in plaats van slechts 10 zoals mensen.

Op hardwareniveau werkt de computer op enkele bits met precies dezelfde methode. Gelukkig is dat geabstraheerd voor programmeurs. Bits is slechts twee cijfers, want dat is gemakkelijk weer te geven in een stroomlijn. Ofwel is het licht aan, ofwel staat het uit.

Tot slot kan een computer elk nummer als een eenvoudige reeks van karakters weergeven. Dat is waar computers het beste in zijn. Het algoritme voor het converteren tussen een reeks karakters en een interne representatie is vrij complex.

Voor het geval u een praktisch voorbeeld wilt van hoeveel programma’s op een typisch Linux-systeem een groot aantal verwerkingen en uitvoer verwerken:

libgmp - De GNU Multiple Precision Arithmetic Library is de meest gebruikte bibliotheek voor dit doel op Linux-systemen. Een eenvoudig voorbeeld van het vermenigvuldigen van 2^80 met 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);

Dus in principe is het hetzelfde als het gebruik van de normale + - * / operatoren, alleen met een bibliotheek om de getallen op te splitsen en ze intern op te slaan als meerdere machinewoordgrote (d.w.z. 32-bits) getallen. Er zijn ook scanf() type functies voor het omzetten van tekstinvoer naar gehele typen.

De structuur van mpz_t is precies zoals Scott Chamberlain’s voorbeeld van tellen naar 6 met twee handen. Het is in principe een reeks van machinewoord-type mp_limb_t types, en wanneer een getal te groot is om in een machinewoord te passen, gebruikt GMP meerdere mp_limb_t om de hoge/lage delen van het getal op te slaan.

Als je bijvoorbeeld 100000000000000 in de rekenmachine schrijft, zal de computer het berekenen als een Real type getal met decimaal punt. Limiet voor 32 bits die u noemde raakt meer alle Integer type getallen zonder decimaalpunt. Verschillende datatypes gebruiken verschillende methoden om in bits/bytes te komen.

Integer type getallen : Deze tabel kan u helpen het punt te vangen http://msdn.microsoft.com/en-us/library/296az74e.aspx ). Dit raakt de grenzen voor C++. Bijvoorbeeld Int64-type nummer heeft limieten van -9223372036854775808 tot 9223372036854775807.

Rechte typenummers : Reële typegetallen bevatten waarde met zwevende punt en exponent en u kunt veel grotere getallen invoeren, maar met een beperkte nauwkeurigheid/nauwkeurigheid. http://msdn.microsoft.com/en-us/library/6bs3y5ya.aspx ) Bijvoorbeeld LDBL (large double) in C++ heeft een maximale exponent 308, dus mogelijk kunt u als resultaat nummer 9.999 x 10^308 invoeren of hebben, wat betekent dat u in theorie 308(+1) cijfers van 9 zult hebben, maar dat slechts 15 belangrijke cijfers zullen worden gebruikt om het weer te geven, de rest zal verloren gaan, door beperkte precisie.

Bovendien zijn er verschillende programmeertalen en kunnen ze verschillende implementaties van de getalgrenzen hebben. U kunt zich dus voorstellen dat gespecialiseerde toepassingen veel grotere (en/of meer exacte/nauwkeurige) getallen kunnen verwerken dan C++.

Omdat u geen nummer (voor zover het de computer betreft) weergeeft, maar een string , of een opeenvolging van cijfers. Tuurlijk, sommige apps (zoals de rekenmachine, denk ik), die met getallen omgaan, kunnen zo'n getal wel aan, denk ik. Ik weet niet welke trucs ze gebruiken… Ik weet zeker dat sommige van de andere, meer uitgebreide antwoorden dat dekken.

Het grootste deel van de inhoud van dit antwoord kwam oorspronkelijk van dit antwoord (geschreven voordat die andere vraag als een duplicaat werd gemarkeerd). Dus ik bespreek het gebruik van 8-bits waarden (hoewel deze vraag over 32-bits waarden ging), maar dat is oké omdat 8-bits waarden conceptueel eenvoudiger te begrijpen zijn, en dezelfde concepten gelden voor grotere waarden zoals 32-bits rekenen.

Als u twee getallen optelt die 8-bits zijn, is dat het grootste getal dat u kunt krijgen (0xFF + 0xFF = 1FE). In feite, als je twee getallen vermenigvuldigt die 8-bits zijn, is het grootste getal dat je kunt krijgen (0xFF * 0xFF = 0xFE01) nog steeds 16 bits, twee keer van 8-bits.

Nu kun je ervan uitgaan dat een x-bit processor alleen x-bits kan bijhouden. (Bijvoorbeeld, een 8-bit processor kan slechts 8 bits bijhouden.) Dat is niet accuraat. De 8-bit processor ontvangt gegevens in 8-bit brokken (deze “brokken” hebben meestal een formele term: een “woord”. Op een 8-bits processor worden 8-bits woorden gebruikt. Op een 64-bits processor kunnen 64-bits woorden worden gebruikt.)

Dus, als je de computer 3 bytes geeft: Byte #1: de MUL instructie Byte #2: de hoge orde bytes (bijv. 0xA5) Byte #3: de lagere orde bytes (bijv. 0xCB) De computer kan een resultaat genereren dat meer dan 8 bits is. De CPU kan resultaten als deze genereren: 0100 0000 0100 0010 xxxx xxxx xxxx xxxx 1101 0111 a.k.a.: 0x4082xxxxD7 Nu, laat me dat voor u interpreteren: 0x betekent gewoon dat de volgende cijfers hexadecimaal zijn.
Ik zal de “40” even in detail bespreken. 82 maakt deel uit van het “A” register, wat een serie van 8 bits is. xx en xx maken deel uit van twee andere registers, genaamd het “B” register en het “C” register. De reden dat ik die bits niet heb gevuld met nullen of enen is dat een “ADD”-instructie (gestuurd naar de CPU) ertoe kan leiden dat die bits onveranderd blijven door de instructie (terwijl de meeste andere bits die ik in dit voorbeeld gebruik veranderd kunnen worden, behalve sommige van de vlagbits). D7 zou in meer bits passen, genaamd het “D”-register. Een register is slechts een stukje geheugen. Registers zijn ingebouwd in de CPU’s, zodat de CPU toegang heeft tot registers zonder dat er interactie met het geheugen op een RAM-stick nodig is.

Dus het wiskundige resultaat van 0xA5 maal 0xCB is 0x82D7.

Nu, waarom zijn de bits gesplitst in de A en D registers in plaats van de A en B registers, of de C en D registers? Nou, nogmaals, dit is een voorbeeldscenario dat ik gebruik, bedoeld om in concept vrij gelijkaardig te zijn aan een echte assemblagetaal (Intel x86 16-bit, zoals gebruikt door de Intel 8080 en 8088 en veel nieuwere CPU’s). Er kunnen een aantal gemeenschappelijke regels zijn, zoals het “C”-register dat typisch wordt gebruikt als een index voor het tellen van operaties (typisch voor lussen), en het “B”-register dat wordt gebruikt voor het bijhouden van offsets die helpen bij het specificeren van geheugenlocaties. Dus, “A” en “D” kunnen meer gebruikelijk zijn voor sommige van de gemeenschappelijke rekenkundige functies.

Elke CPU-instructie zou enige documentatie moeten hebben, gebruikt door mensen die programmeren in Assembly. Die documentatie zou moeten specificeren welke registers door elke instructie worden gebruikt. (De keuze van de te gebruiken registers wordt dus vaak gespecificeerd door de ontwerpers van de CPU, niet door de programmeurs van de Assembly-taal. Hoewel, er kan enige flexibiliteit zijn.)

Nu, terug naar de “40” in het bovenstaande voorbeeld: dat is een serie bits, vaak het “vlaggenregister” genoemd. Elk bit in het vlaggenregister heeft een naam. Er is bijvoorbeeld een “overflow” bit dat de CPU kan instellen als het resultaat groter is dan de ruimte die een byte van de resultaten kan opslaan. (Het “overflow”-bit wordt vaak aangeduid met de verkorte naam “OF”. Dat is een hoofdletter o, geen nul). Software kan de waarde van deze vlag controleren en het “probleem” opmerken. Het werken met dit bit wordt vaak onzichtbaar behandeld door talen van een hoger niveau, dus beginnende programmeurs leren vaak niet hoe ze met de CPU-vlaggen moeten omgaan. Echter, assemblage programmeurs hebben vaak toegang tot sommige van deze vlaggen op een manier die erg lijkt op andere variabelen.

Bijvoorbeeld, je kunt meerdere ADD instructies hebben. Eén ADD instructie kan 16 bits van de resultaten in het A register en het D register opslaan, terwijl een andere instructie gewoon de 8 lage bits in het A register kan opslaan, het D register kan negeren en de overloopbit kan specificeren. Later (na het opslaan van de resultaten van het A-register in het hoofdgeheugen) zou u een andere ADD-instructie kunnen gebruiken die alleen de 8 hoge bits in een register opslaat (mogelijk het A-register.) Of u een overloopvlag moet gebruiken, kan afhangen van welke vermenigvuldigingsinstructie u gebruikt.

(Er is ook vaak een “underflow” flag, voor het geval je te veel aftrekt om in het gewenste resultaat te passen.)

Om je te laten zien hoe ingewikkeld het is: De Intel 4004 was een 4-bit CPU De Intel 8008 was een 8-bit CPU. Het had 8-bits registers met de namen A, B, C en D. De Intel 8086 was een 16-bits CPU. Het had 16-bits registers met de naam AX, BX, CX en DX. De Intel 80386 was een 32-bit CPU. Het had 32-bits registers met de namen EAX, EBX, ECX en EDX. De Intel x64 CPU’s hebben 64-bits registers met de namen RAX, RBX, RCX en RDX. De x64-chips kunnen 16-bits code uitvoeren (in sommige bedrijfsmodi) en kunnen 16-bits instructies interpreteren. Daarbij zijn de bits waaruit het AX-register bestaat de helft van de bits waaruit het EAX-register bestaat, wat de helft is van de bits waaruit het RAX-register bestaat. Dus wanneer u de waarde van AX verandert, verandert u ook de EAX en RAX, omdat de bits die door AX worden gebruikt deel uitmaken van de bits die door RAX worden gebruikt. (Als u EAX verandert met een waarde die een veelvoud is van 65.536, dan zijn de lage 16 bits onveranderd zodat AX niet zou veranderen. Als je EAX verandert met een waarde die geen veelvoud is van 65,536, dan zou dat ook invloed hebben op AX.)

Er zijn meer vlaggen en registers dan alleen de vlaggen en registers die ik heb genoemd. Ik heb eenvoudigweg enkele veelgebruikte vlaggen gekozen om een eenvoudig conceptueel voorbeeld te geven.

Nu, als je op een 8-bit CPU zit, kan het zijn dat je, wanneer je naar het geheugen schrijft, wat beperkingen vindt om te kunnen verwijzen naar een adres van 8-bits, niet naar een adres van 4 bits of 16-bits. De details zullen variëren op basis van de CPU, maar als u dergelijke beperkingen heeft, dan kan de CPU te maken hebben met 8-bits woorden, daarom wordt de CPU meestal aangeduid als een “8-bits CPU”.