Kann ich davon ausgehen, dass die Größe von long int immer 4 Bytes beträgt?

Stimmt es immer, dass long int(was meines Wissens ein Synonym für ist long) 4Bytes sind?

Kann ich mich darauf verlassen? Wenn nicht, könnte dies für ein POSIX-basiertes Betriebssystem zutreffen?

Die Standards sagen nichts über die genaue Größe von Ganzzahltypen aus char. In der Regel longist dies 32-Bit auf 32-Bit-Systemen und 64-Bit auf 64-Bit-Systemen.

Der Standard legt jedoch eine Mindestgröße fest . Aus Abschnitt 5.2.4.2.1 des C-Standards :

1 Die unten angegebenen Werte sind durch konstante Ausdrücke zu ersetzen, die für die Verwendung in #ifVorverarbeitungsrichtlinien geeignet sind . Darüber hinaus wird mit Ausnahme von CHAR_BITund MB_LEN_MAXdas Folgende durch Ausdrücke ersetzt, die denselben Typ haben wie ein Ausdruck, der ein Objekt des entsprechenden Typs ist, der gemäß den ganzzahligen Beförderungen konvertiert wurde. Ihre implementierungsdefinierten Werte müssen gleich oder größer (absoluter Wert) sein als die angegebenen Werte mit demselben Vorzeichen.

...

• Mindestwert für ein Objekt vom Typ long int

  LONG_MIN -2147483647 // - (2 ^ 31−1)

• Maximalwert für ein Objekt vom Typ long int

  LONG_MAX +2147483647 // 2 ^ 31−1

Dieses besagt , dass ein long int muss ein Minimum von 32 Bit sein, kann aber größer sein. Auf einem Computer mit CHAR_BIT8 ergibt dies eine minimale Bytegröße von 4. Auf einem Computer mit z. B. CHAR_BIT16 kann a long intjedoch 2 Byte lang sein.

Hier ist ein Beispiel aus der Praxis. Für den folgenden Code:

#include <stdio.h>

int main ()
{
    printf("sizeof(long) = %zu\n", sizeof(long));
    return 0;
}

Ausgabe unter Debian 7 i686:

sizeof (long) = 4

Ausgabe unter CentOS 7 x64:

sizeof (long) = 8

Nein, Sie können keine Annahmen zur Größe treffen. Wenn Sie einen Typ einer bestimmten Größe benötigen, können Sie die in definierten Typen verwenden stdint.h. Es definiert die folgenden Typen:

• int8_t: 8-Bit signiert
• uint8_t: vorzeichenloses 8-Bit
• int16_t: 16-Bit signiert
• uint16_t: vorzeichenloses 16-Bit
• int32_t: signiertes 32-Bit
• uint32_t: 32-Bit ohne Vorzeichen
• int64_t: 64-Bit signiert
• uint64_t: 64-Bit ohne Vorzeichen

Der stdint.hHeader ist in Abschnitt 7.20 der Norm beschrieben, die genauen Breitentypen in Abschnitt 7.20.1.1. Der Standard besagt, dass diese Typedefs optional sind, aber in den meisten Implementierungen vorhanden sind.

Nein, weder der C-Standard noch POSIX garantieren dies, und tatsächlich verfügen die meisten Unix-ähnlichen 64-Bit-Plattformen über 64 Bit (8 Byte) long.

Verwenden Sie Code sizeof(long int)und überprüfen Sie die Größe. Auf dem System, auf dem Sie gerade arbeiten, erhalten Sie die Größe von long int in Byte. Die Antwort auf Ihre Frage lautet insbesondere NEIN. Es ist nirgends in C oder in POSIX oder irgendwo garantiert.

Wie von @delnan hervorgehoben, behalten POSIX-Implementierungen die Größe von longund intwie nicht angegeben bei und unterscheiden sich häufig zwischen 32-Bit- und 64-Bit-Systemen.

Die Länge von longhängt hauptsächlich von der Hardware ab (häufig passend zur Größe der Datenregister auf der CPU und manchmal auch zu anderen softwarebezogenen Problemen wie dem Betriebssystemdesign und der ABI-Schnittstelle).

Es sizeofist keine Funktion, sondern eine Compiler-Direktive *, sodass Ihr Code bei der Verwendung keine Operationen verwendet sizeof- es ist dasselbe wie das Schreiben einer Zahl, nur dass er portabel ist.

verwenden:

sizeof(long int)

* Wie Dave in den Kommentaren hervorhob, sizeofwird zur Laufzeit berechnet, wenn es unmöglich ist, den Wert während der Kompilierung zu berechnen, z. B. wenn Arrays mit variabler Länge verwendet werden.

sizeofBerücksichtigt auch, wie in einem anderen Kommentar ausgeführt, die von der Implementierung verwendete Auffüllung und Ausrichtung, was bedeutet, dass die tatsächlich verwendeten Bytes von der Größe im Speicher abweichen können (dies kann beim Verschieben von Bits wichtig sein).

Wenn Sie nach Variablen stdint.hmit bestimmter Bytegröße suchen, sollten Sie ein Bytearray oder (ich würde davon ausgehen, dass dies unterstützt wird) die von C99 in definierten Typen verwenden - wie von @dbush vorgeschlagen.

Als wir C zum ersten Mal auf Hardware der ICL-Serie 39 implementiert haben, haben wir den Standard beim Wort genommen und die Datentypen der natürlichen Darstellung auf dieser Maschinenarchitektur zugeordnet, die short= 32 Bit, int= 64 Bit, long= 128 Bit war.

Wir haben jedoch festgestellt, dass keine ernsthaften C-Anwendungen funktionieren. Sie alle nahmen das Mapping short= 16, int= 32, long= 64 an, und wir mussten den Compiler ändern, um dies zu unterstützen.

Was auch immer der offizielle Standard sagt, seit vielen Jahren konvergiert jeder auf long= 64 Bit und es ist unwahrscheinlich, dass sich dies ändert.

Der Standard sagt nichts über die Größe von aus long int, daher hängt er von der Umgebung ab, die Sie verwenden.

Um die Größe long intIhrer Umgebung zu ermitteln, können Sie den sizeofOperator verwenden und die Größe von ermitteln long int. Etwas wie

sizeof(long int)

Der C-Standard erfordert nur die folgenden Punkte zu den Größen der Typen

• int> = 16 Bit,
• lang> = 32 Bit,
• lang lang (seit C99)> = 64 Bit
• sizeof (char) <= sizeof (kurz) <= sizeof (int) <= sizeof (lang) <= sizeof (lang lang)
• sizeof (char) == 1
• CHAR_BIT> = 8

Die übrigen sind definierte Implementierungen, daher ist es nicht verwunderlich, wenn man auf Systeme stößt, in denen int 18/24/36/60 Bits hat, die komplement-signierte Form, sizeof (char) == sizeof (short) == sizeof (int) == sizeof (long) == 4, 48-Bit lang oder 9-Bit-Zeichen wie exotische Architekturen, die den Standardausschüssen am Herzen liegen, und Liste der Plattformen, die vom C-Standard unterstützt werden

Der obige Punkt über long int ist völlig falsch. Die meisten Linux / Unix-Implementierungen definieren Long als 64-Bit-Typ, aber es sind nur 32 Bit in Windows, da sie unterschiedliche Datenmodelle verwenden (siehe Tabelle hier 64-Bit-Computing ), und dies ist unabhängig von 32 oder 64-Bit OS Version.

Quelle

Der Compiler bestimmt die Größe basierend auf dem Hardwaretyp und dem Betriebssystem.

Daher sollten keine Annahmen bezüglich der Größe getroffen werden.

Nein, das können Sie nicht annehmen, da die Größe des "langen" Datentyps von Compiler zu Compiler unterschiedlich ist. Weitere Informationen finden
Sie in diesem Artikel.

Kurze Antwort: Nein! Sie können keine festen Annahmen über die Größe von treffen long int. Weil der Standard (C-Standard oder POSIX) die Größe von nicht dokumentiertlong int (wie wiederholt betont). Um nur ein Gegenbeispiel zu Ihrer Überzeugung zu liefern, haben die meisten 64-Bit-Systeme die longGröße 64! Um die Portabilität zu maximieren, verwenden Sie sie sizeofangemessen.

Verwenden Sie sizeof(long int)diese Option , um die Größe zu überprüfen. Sie gibt die Größe longin Byte zurück. Der Wert ist system- oder umgebungsabhängig. Das heißt, der Compiler bestimmt die Größe basierend auf der Hardware und dem Betriebssystem.

Aus Usrmiscs Blog:

Der Standard überlässt es vollständig dem Compiler, was auch bedeutet, dass derselbe Compiler es von Optionen und Zielarchitektur abhängig machen kann.

Also kannst du nicht .

Übrigens long intkönnte sogar das gleiche sein wie long.