Hängt die Größe eines Int vom Compiler und / oder Prozessor ab?

Würde die Größe einer Ganzzahl vom Compiler, Betriebssystem und Prozessor abhängen?

Die Antwort auf diese Frage hängt davon ab, wie weit wir von praktischen Überlegungen entfernt sind.

Letztendlich hängt theoretisch alles in C und C ++ vom Compiler und nur vom Compiler ab. Hardware / OS spielt überhaupt keine Rolle. Dem Compiler steht es frei, eine Hardware-Abstraktionsschicht beliebiger Dicke zu implementieren und absolut alles zu emulieren. Nichts hindert eine C- oder C ++ - Implementierung daran, den intTyp einer beliebigen Größe und Darstellung zu implementieren , sofern er groß genug ist, um die im Sprachstandard festgelegten Mindestanforderungen zu erfüllen. Praktische Beispiele für eine solche Abstraktionsebene sind leicht verfügbar, z. B. Programmiersprachen, die auf der Plattform "Virtual Machine" basieren, wie Java.

C und C ++ sollen jedoch hocheffiziente Sprachen sein. Um maximale Effizienz zu erzielen, muss eine C- oder C ++ - Implementierung bestimmte Überlegungen berücksichtigen, die von der zugrunde liegenden Hardware abgeleitet sind. Aus diesem Grund ist es sehr sinnvoll sicherzustellen, dass jeder Basistyp auf einer Darstellung basiert, die direkt (oder fast direkt) von der Hardware unterstützt wird. In diesem Sinne hängt die Größe der Basistypen von der Hardware ab.

Mit anderen Worten, eine bestimmte C- oder C ++ - Implementierung für eine 64-Bit-Hardware- / Betriebssystemplattform kann absolut kostenlos intals vorzeichenbehafteter 71-Bit-1-Komplement-Integraltyp implementiert werden , der 128 Bit Speicher belegt, wobei die anderen 57 Bit als Füllbits verwendet werden Diese sind immer erforderlich, um das Geburtsdatum der Freundin des Compilerautors zu speichern. Diese Implementierung hat sogar einen gewissen praktischen Wert: Sie kann verwendet werden, um Laufzeitprüfungen der Portabilität von C / C ++ - Programmen durchzuführen. Aber hier würde der praktische Nutzen dieser Implementierung enden. Erwarten Sie nicht, dass so etwas in einem "normalen" C / C ++ - Compiler zu sehen ist.

Ja, dies hängt sowohl von Prozessoren (genauer gesagt ISA, Befehlssatzarchitektur, z. B. x86 und x86-64) als auch von Compilern einschließlich des Programmiermodells ab. In 16-Bit-Computern betrug die Größe von (int) beispielsweise 2 Byte. 32-Bit-Maschinen haben 4 Bytes für int. Es wurde angenommen, dass es sich intum die native Größe eines Prozessors handelt, dh um die Größe des Registers. 32-Bit-Computer waren jedoch so beliebt, und für das 32-Bit-Programmiermodell wurde eine große Anzahl von Software geschrieben. Es wäre also sehr verwirrend, wenn ein 64-Bit-Computer 8 Bytes für hätte int. Sowohl Linux als auch Windows bleiben 4 Bytes für int. Sie unterscheiden sich jedoch in der Größe von long.

Schauen Sie sich das 64-Bit-Programmiermodell wie LP64 für die meisten * nix und LLP64 für Windows an:

• http://www.unix.org/version2/whatsnew/lp64_wp.html
• http://en.wikipedia.org/wiki/64-bit#64-bit_data_models

Solche Unterschiede sind eigentlich ziemlich peinlich, wenn Sie Code schreiben, der sowohl unter Windows als auch unter Linux funktionieren sollte. Also, ich bin immer mit int32_toder int64_tanstatt longüber stdint.h .

Ja es würde. Meinten sie "wovon würde es abhängen: vom Compiler oder vom Prozessor"? In diesem Fall lautet die Antwort im Grunde "beides". Normalerweise ist intes nicht größer als ein Prozessorregister (es sei denn, das ist kleiner als 16 Bit), aber es könnte kleiner sein (z. B. ein 32-Bit-Compiler, der auf einem 64-Bit-Prozessor ausgeführt wird). Im Allgemeinen benötigen Sie jedoch einen 64-Bit-Prozessor, um Code mit einem 64-Bit-Int auszuführen.

Basierend auf einigen kürzlich durchgeführten Untersuchungen habe ich mich mit Firmware-Interviews befasst:

Die wichtigste Auswirkung der Prozessor-Bit-Architektur, dh 8 Bit, 16 Bit, 32 Bit, 64 Bit, besteht darin, wie Sie jedes Informationsbyte am effizientesten speichern müssen, um Variablen in der minimalen Anzahl von Zyklen am besten zu berechnen.

Die Bitgröße Ihres Prozessors gibt an, welche natürliche Wortlänge die CPU in einem Zyklus verarbeiten kann. Eine 32-Bit-Maschine benötigt 2 Zyklen, um ein 64-Bit-Double zu verarbeiten, wenn es im Speicher richtig ausgerichtet ist. Die meisten PCs waren und sind 32-Bit-Computer, daher der wahrscheinlichste Grund für die typische Affinität des C-Compilers zu 32-Bit-Ganzzahlen mit Optionen für größere Gleitkommazahlen und lange lange Ints.

Natürlich können Sie größere Variablengrößen berechnen, sodass in diesem Sinne die Bitarchitektur der CPU bestimmt, wie größere und kleinere Variablen gespeichert werden müssen, um die bestmögliche Verarbeitungseffizienz zu erzielen. Dies ist jedoch keineswegs ein begrenzender Faktor bei der Definition von Bytegrößen Für Ints oder Chars ist dies Teil von Compilern und was durch Konventionen oder Standards vorgeschrieben ist.

Ich fand diese Seite sehr hilfreich, http://www.geeksforgeeks.org/archives/9705 , um zu erklären, wie sich die natürliche Wortlänge der CPU darauf auswirkt, wie größere und kleinere Variablentypen gespeichert und verarbeitet werden, insbesondere im Hinblick auf das Packen von Bits in Strukturen. Sie müssen genau wissen, wie Sie Variablen zuweisen, da größere Variablen im Speicher ausgerichtet werden müssen, damit sie die geringste Anzahl von Zyklen benötigen, wenn sie durch die Wortlänge der CPU geteilt werden. Dies fügt Dingen wie Strukturen viel potenziell unnötigen Puffer / leeren Speicherplatz hinzu, wenn Sie die Zuordnung Ihrer Variablen schlecht ordnen.

Die einfache und richtige Antwort ist, dass es vom Compiler abhängt. Das bedeutet nicht, dass Architektur irrelevant ist, aber der Compiler kümmert sich darum, nicht um Ihre Anwendung. Man könnte genauer sagen, es hängt von der (Ziel-) Architektur des Compilers ab, zum Beispiel, ob seine 32 Bit oder 64 Bit.

Angenommen, Sie haben eine Windows-Anwendung, die eine Datei erstellt, in der sie ein intPlus und andere Dinge schreibt und zurückliest. Was passiert, wenn Sie dies sowohl in 32-Bit- als auch in 64-Bit-Fenstern ausführen? Was passiert, wenn Sie die auf einem 32-Bit-System erstellte Datei kopieren und im 64-Bit-System öffnen?

Sie könnten denken, dass die Größe von int in jeder Datei unterschiedlich sein wird, aber nein, sie werden gleich sein, und dies ist der Kern der Frage. Sie wählen die Einstellungen im Compiler aus, die auf eine 32-Bit- oder 64-Bit-Architektur abzielen sollen, und das bestimmt alles.

Die Größe der Datentypen hängt vom Prozessor ab, da der Compiler den Zugriff auf die CPU im nächsten Byte erleichtern möchte. Beispiel: Wenn der Prozessor 32-Bit ist, wählt der Compiler die int-Größe möglicherweise nicht als 2 Byte (wobei er 4 Byte auswählen soll), da der Zugriff auf weitere 2 Bytes dieses int (4 Byte) zusätzlichen CPU-Zyklus erfordert, der verschwendet wird. Wenn der Compiler int als 4 Byte wählt, kann die CPU auf einmal auf volle 4 Byte zugreifen, was Ihre Anwendung beschleunigt.

Vielen Dank

Die Größe des int entspricht der Wortlänge, die von der zugrunde liegenden ISA abhängt. Der Prozessor ist nur die Hardware-Implementierung des ISA und der Compiler ist nur die softwareseitige Implementierung des ISA. Alles dreht sich um die zugrunde liegende ISA. Das beliebteste ISA ist heutzutage Intels IA-32. Es hat eine Wortlänge von 32 Bit oder 4 Byte. 4 Bytes können die maximale Größe von 'int'-Compilern (nur int, nicht kurz oder lang) sein. basierend auf IA-32, könnte verwenden.

Die Größe des Datentyps hängt im Wesentlichen vom Typ des Compilers ab, und die Compiler werden auf der Grundlage der Architektur der Prozessoren entworfen, sodass der externe Datentyp als vom Compiler abhängig angesehen werden kann. Die Ex-Größe der Ganzzahl beträgt 2 Byte im 16-Bit-TC-Compiler, aber 4 Byte im gcc-Compiler, obwohl sie im selben Prozessor ausgeführt werden

http://www.agner.org/optimize/calling_conventions.pdf

"3 Datendarstellung" enthält einen guten Überblick darüber, was Compiler mit integralen Typen tun.

Ja, ich fand, dass die Größe von int in Turbo C 2 Bytes betrug, während sie wie im MSVC-Compiler 4 Bytes betrug.

Grundsätzlich ist die Größe von int die Größe der Prozessorregister.