Ist die Größe von C "int" 2 Bytes oder 4 Bytes?

Besetzt eine Integer-Variable in C 2 Bytes oder 4 Bytes? Von welchen Faktoren hängt es ab?

Die meisten Lehrbücher sagen, dass ganzzahlige Variablen 2 Bytes belegen. Wenn ich jedoch ein Programm ausführe, das die aufeinanderfolgenden Adressen eines Arrays von Ganzzahlen druckt, wird der Unterschied von 4 angezeigt.

Ich weiß, dass es gleich ist sizeof(int). Die Größe eines intist wirklich compilerabhängig. Früher, als Prozessoren 16 Bit waren, waren intes 2 Bytes. Heutzutage sind es meistens 4 Bytes auf 32-Bit- und 64-Bit-Systemen.

Immer noch mit sizeof(int) ist jedoch der beste Weg, um die Größe einer Ganzzahl für das spezifische System zu ermitteln, auf dem das Programm ausgeführt wird.

BEARBEITEN: Falsche Anweisung intbehoben, die auf den meisten 64-Bit-Systemen 8 Byte beträgt. Zum Beispiel sind es 4 Bytes bei 64-Bit-GCC.

Dies ist einer der Punkte in C, die zunächst verwirrend sein können, aber der C-Standard gibt nur einen Mindestbereich für Ganzzahltypen an, der garantiert unterstützt wird. intist garantiert in der Lage, -32767 bis 32767 zu halten, was 16 Bit erfordert. In diesem Fall intsind es 2 Bytes. Implementierungen können jedoch über dieses Minimum hinausgehen, da Sie sehen werden, dass viele moderne Compiler int32-Bit erstellen (was auch 4 Bytes ziemlich allgegenwärtig bedeutet).

Der Grund, warum Ihr Buch 2 Bytes sagt, ist höchstwahrscheinlich, weil es alt ist. Zu einer Zeit war dies die Norm. Im Allgemeinen sollten Sie den sizeofOperator immer verwenden , wenn Sie herausfinden möchten, wie viele Bytes sich auf der von Ihnen verwendeten Plattform befinden.

Um dies zu beheben, hat C99 neue Typen hinzugefügt, bei denen Sie explizit nach einer bestimmten Ganzzahl fragen können, z. B. int16_toder int32_t. Zuvor gab es keine universelle Möglichkeit, eine Ganzzahl mit einer bestimmten Breite zu erhalten (obwohl die meisten Plattformen ähnliche Typen pro Plattform bereitstellten).

Es gibt keine spezifische Antwort. Das hängt von der Plattform ab. Es ist implementierungsdefiniert. Es kann 2, 4 oder etwas anderes sein.

Die Idee dahinter intwar, dass es der natürlichen "Wort" -Größe auf der gegebenen Plattform entsprechen sollte: 16 Bit auf 16-Bit-Plattformen, 32 Bit auf 32-Bit-Plattformen, 64 Bit auf 64-Bit-Plattformen. Aus Gründen der Abwärtskompatibilität bevorzugen einige Compiler jedoch die 32-Bit-Version, intselbst auf 64-Bit-Plattformen.

Die Zeit von 2 Byte intist jedoch längst vorbei (16-Bit-Plattformen?), Es sei denn, Sie verwenden eine eingebettete Plattform mit 16-Bit-Wortgröße. Ihre Lehrbücher sind wahrscheinlich sehr alt.

Die Antwort auf diese Frage hängt davon ab, welche Plattform Sie verwenden.
Unabhängig von der Plattform können Sie jedoch zuverlässig die folgenden Typen annehmen:

 [8-bit] signed char: -127 to 127
 [8-bit] unsigned char: 0 to 255
 [16-bit]signed short: -32767 to 32767
 [16-bit]unsigned short: 0 to 65535
 [32-bit]signed long: -2147483647 to 2147483647
 [32-bit]unsigned long: 0 to 4294967295
 [64-bit]signed long long: -9223372036854775807 to 9223372036854775807
 [64-bit]unsigned long long: 0 to 18446744073709551615

Besetzt eine Integer-Variable in C 2 Bytes oder 4 Bytes?

Dies hängt von der verwendeten Plattform und der Konfiguration Ihres Compilers ab. Die einzig maßgebliche Antwort besteht darin, mithilfe des sizeofOperators zu ermitteln, wie groß eine Ganzzahl in Ihrer spezifischen Situation ist.

Von welchen Faktoren hängt es ab?

Die Reichweite sollte am besten berücksichtigt werden, anstatt die Größe . Beide variieren in der Praxis, obwohl es viel narrensicherer ist, Variablentypen nach Bereich als Größe auszuwählen, wie wir sehen werden. Es ist auch wichtig anzumerken, dass der Standard uns dazu ermutigt, die Auswahl unserer Ganzzahltypen eher nach Bereich als nach Größe in Betracht zu ziehen. Lassen Sie uns jedoch zunächst die Standardpraxis ignorieren und unsere Neugierde untersuchen sizeof, Bytes CHAR_BITund Ganzzahldarstellung untersuchen das Kaninchenloch und sehen Sie es selbst ...

sizeof, Bytes und CHAR_BIT

Die folgende Aussage aus dem C-Standard (oben verlinkt) beschreibt dies in Worten, von denen ich glaube, dass sie nicht verbessert werden können.

Der sizeofOperator gibt die Größe (in Bytes) seines Operanden an, der ein Ausdruck oder der Name eines Typs in Klammern sein kann. Die Größe wird aus dem Typ des Operanden bestimmt.

Die Annahme eines klaren Verständnisses führt uns zu einer Diskussion über Bytes . Es wird allgemein angenommen, dass ein Byte aus acht Bits besteht, obwohl tatsächlich angegeben CHAR_BITwird, wie viele Bits in einem Byte enthalten sind . Dies ist nur eine weitere dieser Nuancen, die bei der Betrachtung der gemeinsamen Zwei- (oder Vier-) Byte-Ganzzahlen nicht berücksichtigt wird .

Lassen Sie uns die Dinge so weit zusammenfassen:

• sizeof => Größe in Bytes und
• CHAR_BIT => Anzahl der Bits im Byte

Je nach System kann sizeof (unsigned int)also jeder Wert größer als Null sein (nicht nur 2 oder 4), als wäre er CHAR_BIT16, dann enthält ein einzelnes (16-Bit-) Byte genügend Bits, um die durch die beschriebene 16-Bit-Ganzzahl darzustellen Standards (unten angegeben). Das sind nicht unbedingt nützliche Informationen, oder? Lassen Sie uns tiefer eintauchen ...

Ganzzahlige Darstellung

Der C-Standard gibt hier die Mindestgenauigkeit / den Mindestbereich für alle Standard-Integer-Typen (und CHAR_BITauch fwiw) an . Daraus können wir ein Minimum ableiten, wie viele Bits zum Speichern des Werts erforderlich sind , aber wir können unsere Variablen auch einfach basierend auf Bereichen auswählen . Dennoch befindet sich hier ein großer Teil der für diese Antwort erforderlichen Details. Zum Beispiel Folgendes, dass der Standard unsigned int(mindestens) 16 Bit Speicher benötigt:

UINT_MAX                                65535 // 2¹⁶ - 1

Somit können wir sehen, unsigned intdass ( mindestens ) 16 Bit erforderlich sind. Hier erhalten Sie die zwei Bytes (unter der Annahme von CHAR_BIT8) ... und später, als diese Grenze auf erhöht wurde 2³² - 1, gaben die Leute stattdessen 4 Bytes an. Dies erklärt die Phänomene, die Sie beobachtet haben:

Die meisten Lehrbücher sagen, dass ganzzahlige Variablen 2 Bytes belegen. Wenn ich jedoch ein Programm ausführe, das die aufeinanderfolgenden Adressen eines Arrays von Ganzzahlen druckt, wird der Unterschied von 4 angezeigt.

Sie verwenden ein altes Lehrbuch und einen Compiler, die Ihnen nicht tragbares C beibringen. Der Autor, der Ihr Lehrbuch geschrieben hat, weiß es vielleicht gar nicht CHAR_BIT. Sie sollten Ihr Lehrbuch (und Ihren Compiler) aktualisieren und sich daran erinnern, dass die IT ein sich ständig weiterentwickelndes Feld ist, dem Sie im Wettbewerb immer einen Schritt voraus sein müssen ... Genug davon; Mal sehen, welche anderen nicht portablen Geheimnisse die zugrunde liegenden Integer-Bytes speichern ...

Wertbits sind das, was die häufigsten Missverständnisse zu zählen scheinen. Im obigen Beispiel wird ein unsignedganzzahliger Typ verwendet, der normalerweise nur Wertbits enthält, sodass der Teufel im Detail leicht übersehen werden kann.

Vorzeichenbits ... Im obigen Beispiel habe ich UINT_MAXals Obergrenze angegeben, unsigned intda dies ein triviales Beispiel ist, um den Wert 16aus dem Kommentar zu extrahieren . Bei vorzeichenbehafteten Typen müssen wir auch das Vorzeichenbit einschließen, um zwischen positiven und negativen Werten zu unterscheiden (das ist das Vorzeichen).

INT_MIN                                -32768 // -(2¹⁵)
INT_MAX                                +32767 // 2¹⁵ - 1

Auffüllen von Bits ... Während es nicht üblich ist, auf Computer zu stoßen, die Auffüllbits in ganzen Zahlen enthalten, lässt der C-Standard dies zu. Einige Maschinen (dh diese ) implementieren größere Ganzzahltypen, indem sie zwei kleinere (vorzeichenbehaftete) Ganzzahlwerte miteinander kombinieren. Wenn Sie vorzeichenbehaftete Ganzzahlen kombinieren, erhalten Sie ein verschwendetes Vorzeichenbit. Dieses verschwendete Bit wird in C als Auffüllen betrachtet . Andere Beispiele für Auffüllen von Bits können Paritätsbits und Trap-Bits umfassen .

Wie Sie sehen können, scheint der Standard die Berücksichtigung von Bereichen wie INT_MIN.. INT_MAXund anderen Minimal- / Maximalwerten aus dem Standard bei der Auswahl von Ganzzahltypen zu fördern , und rät davon ab, sich auf Größen zu verlassen, da andere subtile Faktoren wahrscheinlich vergessen werden, wie z. B. CHAR_BITund Auffüllen von Bits, die Dies kann sich auf den Wert von auswirken sizeof (int)(dh die häufigen Missverständnisse von Zwei-Byte- und Vier-Byte-Ganzzahlen vernachlässigen diese Details).

C99 N1256 Standardentwurf

http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf

Die Größe intund alle anderen Integer-Typen sind implementierungsdefiniert. C99 gibt nur Folgendes an:

• Mindestgröße garantiert
• relative Größen zwischen den Typen

5.2.4.2.1 "Größen von ganzzahligen Typen <limits.h>" gibt die Mindestgrößen an:

1 [...] Ihre implementierungsdefinierten Werte müssen gleich oder größer (absoluter Wert) sein als die angegebenen [...]

• UCHAR_MAX 255 // 2 8 - 1
• USHRT_MAX 65535 // 2 16 - 1
• UINT_MAX 65535 // 2 16 - 1
• ULONG_MAX 4294967295 // 2 32 - 1
• ULLONG_MAX 18446744073709551615 // 2 64 - 1

6.2.5 "Typen" sagt dann:

8 Für zwei beliebige Ganzzahltypen mit derselben Vorzeichen und unterschiedlichem Ganzzahlkonvertierungsrang (siehe 6.3.1.1) ist der Wertebereich des Typs mit kleinerem Ganzzahlkonvertierungsrang ein Teilbereich der Werte des anderen Typs.

und 6.3.1.1 "Boolescher Wert, Zeichen und Ganzzahlen" bestimmt die relativen Konvertierungsränge:

1 Jeder Integer-Typ hat einen Integer-Konvertierungsrang, der wie folgt definiert ist:

• Der Rang von long long int ist größer als der Rang von long int, der größer sein soll als der Rang von int, der größer sein soll als der Rang von short int, der größer sein soll als der Rang von signiertem Zeichen.
• Der Rang eines vorzeichenlosen Integer-Typs entspricht gegebenenfalls dem Rang des entsprechenden vorzeichenbehafteten Integer-Typs.
• Wenn für alle ganzzahligen Typen T1, T2 und T3 T1 einen höheren Rang als T2 und T2 einen höheren Rang als T3 hat, hat T1 einen höheren Rang als T3

Die einzigen Garantien , dass charsein müssen mindestens 8 Bit Breite, shortund intsein müssen , mindestens 16 Bit breit, und longsein müssen , mindestens 32 Bit breit, und das sizeof (char)<= sizeof (short)<= sizeof (int)<= sizeof (long)(gleiches gilt für die unsigned Versionen dieser Typen ).

int kann je nach Plattform zwischen 16 und 64 Bit breit sein.

Ist die Größe von C "int" 2 Bytes oder 4 Bytes?

Die Antwort lautet "Ja" / "Nein" / "Vielleicht" / "Vielleicht nicht".

Die Programmiersprache C gibt Folgendes an: Die kleinste adressierbare Einheit, die unter "Byte" bekannt ist charund auch als "Byte" bezeichnet wird , ist genau CHAR_BITbitbreit, wobei sie CHAR_BITmindestens 8 beträgt.

Ein Byte in C ist also nicht unbedingt ein Oktett , dh 8 Bits. In der Vergangenheit hatte eine der ersten Plattformen, auf denen C-Code (und Unix) ausgeführt wurde, 4 Byte int- aber insgesamt int36 Bit, weil CHAR_BITes 9 war!

intsoll die natürliche Ganzzahlgröße für die Plattform sein, die eine Reichweite von mindestens hat-32767 ... 32767 . Sie können die Größe intder Plattformbytes mit abrufen sizeof(int); Wenn Sie diesen Wert mit multiplizieren CHAR_BIT, wissen Sie, wie breit er in Bits ist.

Während 36-Bit-Maschinen größtenteils tot sind, gibt es immer noch Plattformen mit Nicht-8-Bit-Bytes. Erst gestern gab es eine Frage zu einer Texas Instruments MCU mit 16-Bit-Bytes , die einen C99, C11-kompatiblen Compiler hat.

Auf TMS320C28x scheint es , dass char, shortund intsind alle 16 Bit breit, und damit ein Byte. long intist 2 Bytes und long long intist 4 Bytes. Das Schöne an C ist, dass man für eine Plattform wie diese immer noch ein effizientes Programm schreiben und es sogar tragbar machen kann!

Meistens hängt es von der Plattform ab, die Sie verwenden. Es hängt von Compiler zu Compiler ab. Heutzutage besteht int in den meisten Compilern aus 4 Bytes . Wenn Sie überprüfen möchten, was Ihr Compiler verwendet, können Sie verwenden sizeof(int).

main()
{
    printf("%d",sizeof(int));
    printf("%d",sizeof(short));
    printf("%d",sizeof(long));
}

Das einzige, was der Compiler verspricht, ist, dass die Größe von short gleich oder kleiner als int und die Größe von long gleich oder größer als int sein muss. Wenn also die Größe von int 4 ist, kann die Größe von short 2 oder 4 sein, aber nicht größer als das. Gleiches gilt für long und int. Es heißt auch, dass die Größe von kurz und lang nicht gleich sein kann.

Dies hängt von der Implementierung ab, aber normalerweise benötigen x86 und andere gängige Architekturen wie ARMs int4 Byte. Sie können jederzeit zur Kompilierungszeit mit sizeof(int)oder einem anderen Typ prüfen, den Sie überprüfen möchten.

Wenn Sie sicherstellen möchten, dass Sie einen Typ einer bestimmten Größe verwenden, verwenden Sie die Typen in <stdint.h>

#include <stdio.h>

int main(void) {
    printf("size of int: %d", (int)sizeof(int));
    return 0;
}

Dies gibt 4 zurück, ist aber wahrscheinlich maschinenabhängig.

Ist die Größe von C "int" 2 Bytes oder 4 Bytes?

Besetzt eine Integer-Variable in C 2 Bytes oder 4 Bytes?

C erlaubt, dass "Bytes" etwas anderes als 8 Bits pro "Byte" sind.

CHAR_BIT Anzahl der Bits für das kleinste Objekt, das kein Bitfeld (Byte) ist C11dr §5.2.4.2.1 1

Ein Wert von etwas mehr als 8 wird immer seltener. Verwenden Sie für maximale Portabilität CHAR_BITanstelle von 8. Die Größe eines intIn- Bits in C ist sizeof(int) * CHAR_BIT.

#include <limits.h>
printf("(int) Bit size %zu\n", sizeof(int) * CHAR_BIT);

Von welchen Faktoren hängt es ab?

Die intBitgröße beträgt üblicherweise 32 oder 16 Bit. C festgelegten Mindestbereiche :

Minimalwert für ein Objekt vom Typ int INT_MIN-32767
Maximalwert für ein Objekt vom Typ int INT_MAX+32767
C11dr §5.2.4.2.1 1

Der Mindestbereich für interzwingt eine Bitgröße von mindestens 16 - selbst wenn der Prozessor "8-Bit" war. Eine Größe wie 64 Bit wird in spezialisierten Prozessoren gesehen. Andere Werte wie 18, 24, 36 usw. sind auf historischen Plattformen aufgetreten oder zumindest theoretisch möglich. Moderne Codierung macht sich selten Sorgen über Bitgrößen ohne Potenz von 2 int.

Der Prozessor und die Architektur des Computers steuern die intAuswahl der Bitgröße.

Selbst bei 64-Bit-Prozessoren kann die Compilergröße intaus Kompatibilitätsgründen int32-Bit betragen, da große Codebasen von 32-Bit (oder 32/16) abhängen.

Dies ist eine gute Quelle für die Beantwortung dieser Frage.

Aber diese Frage ist eine Art immer wahrheitsgemäße Antwort: "Ja. Beides."

Das hängt von Ihrer Architektur ab. Wenn Sie auf einem 16-Bit-Computer oder weniger arbeiten, darf dies nicht 4 Byte (= 32 Bit) sein. Wenn Sie auf einem 32-Bit-Computer oder einem besseren Computer arbeiten, beträgt dessen Länge 32-Bit.

Um dies herauszufinden, bereiten Sie Ihr Programm darauf vor, etwas Lesbares auszugeben, und verwenden Sie die Funktion "sizeof". Dies gibt die Größe Ihres deklarierten Datentyps in Byte zurück. Aber seien Sie vorsichtig, wenn Sie dies mit Arrays verwenden.

Wenn Sie deklarieren int t[12];, wird 12 * 4 Byte zurückgegeben. Verwenden Sie einfach, um die Länge dieses Arrays zu ermitteln sizeof(t)/sizeof(t[0]). Wenn Sie eine Funktion aufbauen möchten, die die Größe eines Sendearrays berechnen soll, denken Sie daran, dass if

typedef int array[12];
int function(array t){
    int size_of_t = sizeof(t)/sizeof(t[0]);
    return size_of_t;
}
void main(){
    array t = {1,1,1};  //remember: t= [1,1,1,0,...,0]
    int a = function(t);    //remember: sending t is just a pointer and equal to int* t
   print(a);   // output will be 1, since t will be interpreted as an int itselve. 
}

Das wird also nicht einmal etwas anderes zurückgeben. Wenn Sie ein Array definieren und anschließend versuchen, die Länge zu ermitteln, verwenden Sie sizeof. Wenn Sie ein Array an eine Funktion senden, denken Sie daran, dass der Sendewert nur ein Zeiger auf das erste Element ist. Aber im ersten Fall wissen Sie immer, welche Größe Ihr Array hat. Fall zwei kann herausgefunden werden, indem zwei Funktionen definiert werden und eine gewisse Leistung fehlt. Definieren Sie die Funktion (Array t) und definieren Sie die Funktion2 (Array t, int size_of_t). Rufen Sie "function (t)" auf, messen Sie die Länge durch Kopieren und senden Sie das Ergebnis an function2, wo Sie für variable Arraygrößen alles tun können, was Sie wollen.