C++: Wie groß ist ein Objekt einer leeren Klasse?

Ich habe mich gefragt, was das sein könnte Größe eines Objekts einer leeren Klasse. Es könnte sicherlich nicht 0 Bytes sein, da es möglich sein sollte, darauf wie auf jedes andere Objekt zu verweisen und zu zeigen. Aber wie groß ist so ein Objekt?

Ich habe dieses kleine Programm verwendet:

#include <iostream>
using namespace std;

class Empty {};

int main()
{
    Empty e;
    cerr << sizeof(e) << endl;
    return 0;
}

Die Ausgabe, die ich sowohl auf Visual C++- als auch auf Cygwin-g++-Compilern erhielt, war 1 Byte! Dies war für mich etwas überraschend, da ich erwartet hatte, dass es die Größe des Maschinenworts (32 Bit oder 4 Byte) haben würde.

Kann jemand erklären warum die Größe von 1 Byte? Warum nicht 4 Bytes? Hängt das auch vom Compiler oder der Maschine ab? Kann jemand auch einen zwingenderen Grund dafür angeben, warum ein leeres Klassenobjekt vorhanden ist wird nicht 0 Bytes groß sein?

Zitieren Häufig gestellte Fragen zu Stil und Technik von Bjarne Stroustrup in C++, ist der Grund, warum die Größe ungleich Null ist, “Um sicherzustellen, dass die Adressen von zwei verschiedenen Objekten unterschiedlich sind.” Und die Größe kann 1 sein, weil die Ausrichtung hier keine Rolle spielt, da es nichts zu sehen gibt.

Der Standard besagt, dass alle am meisten abgeleiteten Objekte sizeof() >= 1 haben:

Sofern es sich nicht um ein Bitfeld (class.bit) handelt, soll ein am meisten abgeleitetes Objekt eine Größe ungleich Null haben und ein oder mehrere Bytes Speicher belegen. Unterobjekte der Basisklasse können eine Größe von Null haben.
ISO/IEC FDIS 14882:1998(E) Einführungsobjekt

Das ist wirklich ein Implementierungsdetail. Vor langer Zeit dachte ich, es könnten null Bytes oder tausend Bytes sein, das hat keinen Einfluss auf die Sprachspezifikation. Aber nach einem Blick auf den C++17-Standard (expr.sizeof), sizeof ist so definiert, dass immer ein oder mehr zurückgegeben wird, egal was passiert.

Die Größe einer am meisten abgeleiteten Klasse muss größer als Null sein.

Dies ist unter anderem erforderlich, damit Sie mit Arrays von Objekten und Zeigern darauf umgehen können. Wenn Ihre Elemente dann die Größe Null haben dürften &(array[0]) wäre identisch mit &(array[42])was alle Arten von Chaos in Ihren Verarbeitungsschleifen verursachen wird.

Der Grund, warum es möglicherweise kein Maschinenwort ist, besteht darin, dass es keine Elemente enthält, die tatsächlich erfordern, dass es an einer Wortgrenze ausgerichtet ist (z. B. eine ganze Zahl). Zum Beispiel, wenn Sie platzieren char x; int y; Innerhalb der Klasse taktet mein GCC es mit acht Bytes (seit dem zweiten int muss in dieser Implementierung angeglichen werden).

Allerdings scheint dieser spezielle Wortlaut aus C++20 entfernt worden zu sein, was zumindest die Wahrscheinlichkeit von Objekten, die keinen Platz einnehmen können. Der folgende Text wurde jedoch demselben Abschnitt hinzugefügt:

Bei Anwendung auf eine Klasse ist das Ergebnis die Anzahl der Bytes in einem Objekt dieser Klasse einschließlich aller Polsterungen, die zum Platzieren von Objekten dieses Typs in einem Array erforderlich sind.

Da Arrays in der Lage sein müssen, zwischen Elementen zu unterscheiden, würde das bedeuten sizeof müsste mindestens einen zurückgeben, selbst wenn das Objekt selbst technisch gesehen keinen Platz einnehmen würde.

Also unterschiedliche Formulierungen, aber der gleiche Gesamteffekt.

Obwohl es nicht erforderlich ist, einer leeren Klasse Speicher zuzuweisen, weist der Compiler jedoch den minimal zuweisbaren Speicher zu, der 1 Byte beträgt, um Objekte aus leeren Klassen zu erstellen. Auf diese Weise kann der Compiler zwei Objekte derselben leeren Klasse eindeutig unterscheiden und die Adresse des Objekts einem Zeiger des Typs der leeren Klasse zuweisen.

Ich denke, es könnte hilfreich sein, auf eine Antwort zu verlinken, die dies auch gut erklärt. Es geht um boost::compressed_pair von Logan Capaldo.

Es gibt eine Ausnahme: Arrays der Länge 0

#include <iostream>

class CompletlyEmpty {
  char NO_DATA[0];
};

int main(int argc, const char** argv) {
  std::cout << sizeof(CompletlyEmpty) << '\n';
}

Das kann dir helfen 🙂
http://bytes.com/topic/c/insights/660463-sizeof-empty-class-structure-1-a

Die Größe einer leeren Klasse oder Struktur ist 1

Der Grund dafür läuft darauf hinaus, den Standard richtig zu implementieren. Eines der Dinge, die der C++-Standard sagt, ist, dass “kein Objekt dieselbe Adresse im Speicher haben darf wie irgendeine andere Variable”. Was ist der einfachste Weg, dies sicherzustellen? Stellen Sie sicher, dass alle Typen eine Größe ungleich Null haben. Um dies zu erreichen, fügt der Compiler Strukturen und Klassen, die keine Datenelemente und keine virtuellen Funktionen haben, ein Dummy-Byte hinzu, damit sie eine Größe von 1 statt einer Größe von 0 haben und dann garantiert eine eindeutige Speicheradresse haben.