it-swarm.com.de

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

Belegt eine Integer-Variable in C 2 Bytes oder 4 Bytes? Auf welche Faktoren kommt es an?

Die meisten Lehrbücher besagen, dass Integer-Variablen 2 Bytes belegen. Wenn ich jedoch ein Programm ausführe, das die aufeinanderfolgenden Adressen eines Arrays von Integer-Werten druckt, zeigt es den Unterschied von 4.

124
Rajiv Prathap

Ich weiß, es ist sizeof(int) gleich. Die Größe einer int ist abhängig vom Compiler. Damals, als die Prozessoren 16 Bit hatten, waren int 2 Bytes. Heute sind es bei 32-Bit- und 64-Bit-Systemen meistens 4 Byte. 

Die Verwendung von 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.

EDIT: Die falsche Angabe, dass int auf den meisten 64-Bit-Systemen 8 Byte ist, wurde behoben. Bei 64-Bit-GCC sind dies beispielsweise 4 Byte.

144
yhyrcanus

Dies ist einer der Punkte in C, die anfangs verwirrend sein können. Der C-Standard gibt jedoch nur einen minimum-Bereich für Ganzzahltypen an, der garantiert unterstützt wird. int kann garantiert -32767 bis 32767 halten, was 16 Bit erfordert. In diesem Fall ist int 2 Byte. Implementierungen können jedoch über dieses Minimum hinausgehen, da Sie feststellen werden, dass viele moderne Compiler int 32-Bit machen (was auch 4 Byte ziemlich ubiquitär bedeutet).

Der Grund, warum Ihr Buch 2 Bytes sagt, ist höchstwahrscheinlich, weil es alt ist. Dies war einmal die Norm. Im Allgemeinen sollten Sie immer den Operator sizeof verwenden, wenn Sie herausfinden möchten, wie viele Bytes es auf der von Ihnen verwendeten Plattform gibt.

Um dies zu beheben, fügte C99 neue Typen hinzu, bei denen Sie explizit nach einer bestimmten Integer-Größe fragen können, beispielsweise int16_t oder int32_t. Zuvor gab es keine universelle Methode, um eine ganze Zahl mit einer bestimmten Breite zu erhalten (obwohl die meisten Plattformen ähnliche Typen auf Plattformbasis zur Verfügung stellten).

91
FatalError

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

Die Idee hinter int war, dass sie der natürlichen "Word" -größe auf der angegebenen 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 Rückwärtskompatibilität ziehen es einige Compiler jedoch vor, auch auf 64-Bit-Plattformen die 32-Bit-Variable int einzuhalten.

Die Zeitdauer von 2-Byte int ist lange vorbei (16-Bit-Plattformen?), Es sei denn, Sie verwenden eine eingebettete Plattform mit 16-Bit-Word-Größe. Ihre Lehrbücher sind wahrscheinlich sehr alt.

26
AnT

Die Antwort auf diese Frage hängt von der verwendeten Plattform ab.
Unabhängig von der Plattform können Sie jedoch zuverlässig folgende 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
17
Priyank Arora

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

Das hängt von der verwendeten Plattform und der Konfiguration Ihres Compilers ab. Die einzige maßgebliche Antwort ist die Verwendung des Operators sizeof , um festzustellen, wie groß eine Ganzzahl in Ihrer spezifischen Situation ist.


Was sind die Faktoren, von denen es abhängt?

Range sollte am besten in Betracht gezogen werden, anstatt size . Beides wird in der Praxis variieren, obwohl es viel einfacher ist, Variablentypen nach Bereich als Größe zu wählen, wie wir noch sehen werden. Es ist auch wichtig anzumerken, dass der Standard uns ermutigt, die Auswahl unserer Ganzzahltypen basierend auf Bereich statt Größe zu erwägen, aber für den Moment Lassen Sie uns die Standardpraxis ignorieren und unsere Neugierde sizeof, Bytes und _CHAR_BIT_ und die ganzzahlige Darstellung erforschen ...


sizeof, BYTES UND _CHAR_BIT

Die folgende Aussage aus dem C-Standard (oben verlinkt) beschreibt dies mit Worten, die meines Erachtens nicht verbessert werden können.

Der Operator sizeof gibt die Größe (in Byte) seines Operanden an, der ein Ausdruck oder der in Klammern gesetzte Name eines Typs sein kann. Die Größe ergibt sich aus dem Typ des Operanden.

Unter der Annahme eines klaren Verständnisses werden wir eine Diskussion über bytes führen. Es wird allgemein angenommen, dass ein Byte aus acht Bits besteht, obwohl _CHAR_BIT_ die Anzahl der Bits in einem Byte angibt . Dies ist nur eine dieser Nuancen, die nicht berücksichtigt wird, wenn von den üblichen zwei (oder vier) Byte-Ganzzahlen gesprochen wird.

Lassen Sie uns die Dinge so weit einpacken:

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

Abhängig von Ihrem System könnte sizeof (unsigned int) jeder Wert größer als Null sein (nicht nur 2 oder 4), als ob _CHAR_BIT_ dann 16 ist ein einzelnes (16-Bit-) Byte enthält genug Bits, um die 16-Bit-Ganzzahl darzustellen, die von den Standards beschrieben wird (siehe unten). Das sind nicht unbedingt nützliche Informationen, oder? Tauchen wir tiefer ein ...


Ganzzahlige Darstellung

Der C-Standard gibt die minimale Genauigkeit/den minimalen Bereich für alle ganzzahligen Standardtypen an (und _CHAR_BIT_ auch fwiw) hier . Daraus können wir ein Minimum ableiten, für wie viele Bits erforderlich sind, um den Wert zu speichern, aber wir können auch einfach wählen Unsere Variablen basieren auf Bereiche . Dennoch liegt hier ein großer Teil der für diese Antwort erforderlichen Details. Zum Beispiel das Folgende, dass der Standard _unsigned int_ (mindestens) 16 Bit Speicher benötigt:

_UINT_MAX                                65535 // 2¹⁶ - 1
_

Somit können wir sehen, dass _unsigned int_ ( mindestens ) 16 Bits benötigt, was ist Wo Sie die zwei Bytes (angenommen, _CHAR_BIT_ ist 8) ... und später, als diese Grenze auf _2³² - 1_ anstieg, gaben die Leute stattdessen 4 Bytes an . Dies erklärt die Phänomene, die Sie beobachtet haben:

In den meisten Lehrbüchern heißt es, dass ganzzahlige Variablen 2 Bytes belegen. Aber wenn ich ein Programm ausführe, das die aufeinanderfolgenden Adressen eines Arrays von ganzen Zahlen druckt, zeigt es den Unterschied von 4.

Sie verwenden ein uraltes Lehrbuch und einen Compiler, die Ihnen nicht portierbares C beibringen. Der Autor, der Ihr Lehrbuch geschrieben hat, weiß möglicherweise nicht einmal von _CHAR_BIT_. Sie sollten sollte Ihr Lehrbuch (und Ihren Compiler) aktualisieren und sich bemühen, sich daran zu erinnern, dass I.T. ist ein sich ständig weiterentwickelndes Feld, in dem man vor bleiben muss, um mithalten zu können ... Genug davon; Mal sehen, welche anderen nicht portierbaren Geheimnisse diese zugrunde liegenden Integer-Bytes speichern ...

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

Vorzeichenbits ... Im obigen Beispiel habe ich _UINT_MAX_ als Obergrenze für _unsigned int_ angegeben, weil es ein triviales Beispiel ist Um den Wert _16_ aus dem Kommentar zu extrahieren. Um bei vorzeichenbehafteten Typen zwischen positiven und negativen Werten zu unterscheiden (das ist das Vorzeichen), müssen wir auch das Vorzeichenbit einschließen.

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

Füllbits ... Während es nicht üblich ist, auf Computern mit Füllbits in ganzen Zahlen zu stoßen, lässt der C-Standard dies zu. Einige Maschinen (d. h. 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üllbits können Paritätsbits und Trapbits umfassen.


Wie Sie sehen, scheint der Standard dazu zu ermutigen, Bereiche wie _INT_MIN_.._INT_MAX_ und andere Minimal-/Maximalwerte aus dem Standard bei der Auswahl ganzzahliger Typen und rät davon ab, sich auf Größen zu verlassen, da es andere subtile Faktoren gibt, die wahrscheinlich vergessen werden, wie _CHAR_BIT_ und Füllbits, die den Wert von sizeof (int) beeinflussen können (dh die allgemeinen Missverständnisse von Zwei-Byte- und Vier-Byte-Ganzzahlen vernachlässigt diese Details).

11
Flimzy

C99 N1256 Standardentwurf

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

Die Größe von int und 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 der ganzzahligen Typen <limits.h>" gibt die Mindestgrößen an:

1 [...] Ihre implementierungsdefinierten Werte müssen den angegebenen Werten (Absolutwert) gleich oder größer sein als [...]

  • 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 Integer-Typen mit demselben Vorzeichen und unterschiedlichem Integer-Umsetzungsrang (siehe 6.3.1.1) ist der Wertebereich des Typs mit einem kleineren Integer-Konvertierungsrang eine Teilbereich der Werte des anderen Typs.

und 6.3.1.1 "Boolean, Zeichen und Ganzzahlen" bestimmt die relativen Konvertierungsstufen:

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

  • Der Rang von Long Long Int ist größer als der Rang von Long Int, der ist größer als der Rang von int, der größer ist als der Rang von short int, der größer ist als der Rang eines unterzeichneten Zeichens.
  • Der Rang eines beliebigen vorzeichenlosen Integer-Typs entspricht dem Rang des entsprechenden Gegebenenfalls vorzeichenbehafteter Integer-Typ.
  • Für alle ganzzahligen Typen T1, T2 und T3 haben, wenn T1 einen höheren Rang als T2 hat, und T2 einen höheren Rang als T3, dann hat T1 einen höheren Rang als T3

Die einzigen Garantien sind, dass char mindestens 8 Bit breit sein muss, short und int mindestens 16 Bit breit sind und long mindestens 32 Bit breit sein muss, und dass sizeof (char) <= sizeof (short) <= sizeof (int) <= sizeof (long) (Gleiches gilt für die vorzeichenlosen Versionen dieser Typen). 

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

6
John Bode

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

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 die Größe von int 4 ist, kann die Größe von short 2 oder 4 sein, aber nicht größer als das. Dasselbe gilt für lange und int. Es heißt auch, dass die Größe von kurz und lang nicht gleich sein kann.

5
justpraveen

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

Die Antwort lautet "ja"/"nein"/"vielleicht"/"vielleicht nicht".

Die C-Programmiersprache gibt Folgendes an: Die kleinste adressierbare Einheit, die char und auch "Byte" genannt wird, ist genau CHAR_BIT Bits breit, wobei CHAR_BIT mindestens 8 ist.

Ein Byte in C ist also nicht notwendigerweise ein Oktett, d. H. 8 Bit. In der Vergangenheit hatte eine der ersten Plattformen, auf denen C-Code (und Unix) ausgeführt wurde, 4-Byte-Variable int -, aber insgesamt hatte int 36 Bits, da CHAR_BIT 9 war!

int soll die natürliche Ganzzahl für die Plattform sein, die den Bereich mindestens -32767 ... 32767 hat. Sie können die Größe von int in den Plattform-Bytes mit sizeof(int) erhalten. Wenn Sie diesen Wert mit CHAR_BIT multiplizieren, wissen Sie, wie breit er in Bits ist.


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

Bei TMS320C28x scheint es, dass char, short und intall 16 Bit breit sind und daher ein Byte. long int ist 2 Byte und long long int 4 Byte. Das Schöne an C ist, dass man immer noch ein effizientes Programm für eine solche Plattform schreiben und sogar tragbar machen kann!

4
Antti Haapala

Dies hängt von der Implementierung ab. Normalerweise benötigen x86 und andere gängige Architekturen wie ARM ints jedoch 4 Byte. Sie können immer zur Kompilierzeit überprüfen, indem Sie sizeof(int) oder einen anderen Typ verwenden, den Sie prüfen möchten.

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

3
slartibartfast
#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.

2
thelaws

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

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

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

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_BIT anstelle von 8. Die Größe eines int in Bits in C ist sizeof(int) * CHAR_BIT

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

Auf welche Faktoren kommt es an?

Die int Bitgröße beträgt üblicherweise 32 oder 16 Bit. C spezifizierte minimale Bereiche :

mindestwert für ein Objekt vom Typ intINT_MIN -32767
Maximalwert für ein Objekt vom Typ intINT_MAX +32767
C11dr §5.2.4.2.1 1

Der minimale Bereich für int erzwingt, dass die Bitgröße mindestens 16 - ist, auch wenn der Prozessor "8-Bit" war. Eine Größe wie 64 Bit ist in spezialisierten Prozessoren zu sehen. Andere Werte wie 18, 24, 36 usw. sind auf historischen Plattformen vorgekommen oder zumindest theoretisch möglich. Moderne Codierung macht sich selten Sorgen über Nicht-Bit-Größen von int.

Der Prozessor und die Architektur des Computers steuern die Auswahl der Bitgröße int

Sogar bei 64-Bit-Prozessoren kann die Größe des Compilers int aus Kompatibilitätsgründen 32-Bit sein, da große Codebasen davon abhängen, dass int 32-Bit (oder 32/16) ist.

1
chux

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

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

Das hängt von Ihrer Architektur ab. Wenn Sie auf einem 16-Bit-Computer oder weniger arbeiten, darf er nicht aus 4 Byte (= 32 Bit) bestehen. Wenn Sie an einer 32-Bit-Maschine oder einer besseren Maschine arbeiten, beträgt die Länge 32 Bit. 

Um es herauszufinden, machen Sie Ihr Programm bereit, etwas lesbares auszugeben, und verwenden Sie die Funktion "sizeof". Das gibt die Größe Ihres deklarierten Datentyps in Byte zurück. Aber seien Sie vorsichtig mit Arrays. 

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

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. 
}

Also wird dies nicht einmal etwas anderes zurückgeben. Wenn Sie ein Array definieren und danach 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. Falls Sie jedoch immer wissen, welche Größe Ihr Array hat. Fall zwei kann durch Definieren zweier Funktionen herausgefunden werden und verpasst etwas Leistung. Definieren Sie die Funktion (Array t) und definieren Sie function2 (Array t, int size_of_t). Rufen Sie "function (t)" auf, um die Länge durch einige Kopierarbeiten zu messen, und senden Sie das Ergebnis an function2, wo Sie bei variablen Array-Größen nach Belieben arbeiten können. 

0
Shalec