Wie viele Bytes haben int und long in C++? Die Standardantwort überrascht

Das Rätsel der Größen: Warum verhalten sich int und long auf verschiedenen Compilern unterschiedlich?

Jeder, der sich ernsthaft mit C++ beschäftigt hat, ist früher oder später auf dieses Rätsel gestoßen. Sie schreiben einfachen Code:

#include <iostream>\n\nint main() {\n    std::cout << "Größe von int: " << sizeof(int) << " Bytes\\n";\n    std::cout << "Größe von long: " << sizeof(long) << " Bytes\\n";\n    std::cout << "Größe von long long: " << sizeof(long long) << " Bytes\\n";\n    return 0;\n}

Sie führen es auf Ihrem Laptop aus – Sie erhalten 4, 4, 8. Sie führen es auf einem Linux-Server aus – 4, 8, 8. Und auf einem alten 16-Bit-System (ja, solche gibt es noch!) – 2, 4, 8. Wo liegt der Haken? Warum erlaubt C++, eine für ihre Leistungsfähigkeit und Kontrolle bekannte Sprache, eine solche Unbestimmtheit?

Die Antwort ist einfach und komplex zugleich: Der C++-Standard überlässt die Größen der ganzzahligen Typen bewusst der Implementierung. Das ist kein Fehler, sondern ein Feature, das es der Sprache ermöglicht, auf jeder Hardware zu laufen – von Mikrocontrollern bis zu Supercomputern. Für den Entwickler bedeutet das jedoch eines: Wenn Sie portablen Code schreiben, können Sie sich nicht auf bestimmte Größen verlassen.

Lassen Sie uns klären, was der C++-Standard (von C++98 bis C++23) tatsächlich garantiert und wie Sie der Falle der Plattformabhängigkeit entgehen.

Was garantiert der C++-Standard? Minimale Größen und Hierarchie

Anstatt zu sagen "int ist 4 Bytes", legt der Standard minimale Wertebereiche und eine strenge Größenhierarchie fest. Hier sind die wichtigsten Regeln aus dem Standardentwurf (Abschnitt [basic.fundamental]):

\n
• Mindestgröße von char: 1 Byte (8 Bit, obwohl ein Byte in C++ formal auch größer sein kann).
\n
• Größenhierarchie: sizeof(char) ≤ sizeof(short) ≤ sizeof(int) ≤ sizeof(long) ≤ sizeof(long long).
\n
• Mindestbits:\n
  \n
  • short: mindestens 16 Bit.
  \n
  • int: mindestens 16 Bit.
  \n
  • long: mindestens 32 Bit.
  \n
  • long long: mindestens 64 Bit (hinzugefügt in C++11).
  \n
  \n
\n
• Größe von int: Der Standard empfiehlt, dass int die "natürliche Größe" für die Zielarchitektur hat (normalerweise 4 Bytes auf 32/64-Bit-Systemen).
\n

Beachten Sie: long kann gleich int (auf 32-Bit-Windows) oder long long (auf 64-Bit-Linux) sein. Das ist völlig legal!

Praktisches Beispiel: Überprüfung auf Ihrem System

Führen Sie diesen Code aus und vergleichen Sie die Ergebnisse mit Kollegen auf verschiedenen Betriebssystemen:

#include <iostream>\n#include <climits> // für INT_MAX, LONG_MAX usw.\n\nint main() {\n    std::cout << "Größen in Bytes:\\n";\n    std::cout << "short: " << sizeof(short) << "\\n";\n    std::cout << "int: " << sizeof(int) << "\\n";\n    std::cout << "long: " << sizeof(long) << "\\n";\n    std::cout << "long long: " << sizeof(long long) << "\\n\\n";\n\n    std::cout << "Maximale Werte:\\n";\n    std::cout << "INT_MAX: " << INT_MAX << "\\n";\n    std::cout << "LONG_MAX: " << LONG_MAX << "\\n";\n    std::cout << "LLONG_MAX: " << LLONG_MAX << "\\n";\n    return 0;\n}

Sie werden sehen, dass unter Windows (MSVC) long oft 4 Bytes beträgt, unter Linux (GCC/Clang) jedoch 8 Bytes. Dies ist eine klassische Fehlerquelle beim Portieren von Code zwischen Plattformen.

Warum legt der Standard die Größen nicht fest? Historischer Kontext

Stellen Sie sich die 1970er Jahre vor. Prozessoren waren 8-Bit, 16-Bit, und 32-Bit-Prozessoren kamen gerade erst auf. Die Entwickler von C (und