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

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

Ich habe dieses kleine Programm benutzt:

#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 ein wenig überraschend, da ich erwartet hatte, dass es die Größe des Maschinenworts hat (32 Bit oder 4 Bytes).

Kann jemand erklären, warum die Größe von 1 Byte? Warum nicht 4 Bytes? Ist dies auch vom Compiler oder der Maschine abhängig? Kann jemand einen schlüssigeren Grund dafür angeben, warum ein leeres Klassenobjekt nicht die Größe 0 Bytes hat?

In den häufig gestellten Fragen zu C ++ - Stil und Technik von Bjarne Stroustrup wird angegeben , dass die Größe ungleich Null ist: "Um sicherzustellen, dass die Adressen von zwei verschiedenen Objekten unterschiedlich sind." Und die Größe kann 1 sein, da 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, muss 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) intro.object

Das ist wirklich ein Implementierungsdetail. Vor langer Zeit dachte ich, es könnten null oder tausend Bytes sein, was keinen Einfluss auf die Sprachspezifikation hat. Nach Betrachtung des Standards (Abschnitt 5.3.3) wird sizeofjedoch definiert, dass immer einer oder mehrere zurückgegeben werden, egal was passiert .

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

Dies ist unter anderem erforderlich, damit Sie Arrays von Objekten und Zeigern auf diese verarbeiten können. Wenn Ihre Elemente die Größe Null haben könnten, &(array[0])wäre dies identisch mit &(array[42]), was Ihre Verarbeitungsschleifen in jeder Hinsicht verwüsten würde.

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 (z. B. einer Ganzzahl) ausgerichtet wird. Wenn Sie beispielsweise char x; int y;innerhalb der Klasse platzieren, taktet mein GCC sie mit acht Bytes (da das zweite int in dieser Implementierung ausgerichtet sein muss).

Es gibt eine Ausnahme: Arrays mit einer Länge von 0

#include <iostream>

class CompletlyEmpty {
  char NO_DATA[0];
};

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

Obwohl es nicht erforderlich ist, einer leeren Klasse Speicher zuzuweisen, sondern um Objekte aus leeren Klassen zu erstellen, weist der Compiler den minimalen Speicher zu, der zugewiesen werden kann, nämlich 1 Byte. Auf diese Weise kann der Compiler zwei Objekte derselben leeren Klasse eindeutig unterscheiden und die Adresse des Objekts einem Zeiger des leeren Klassentyps zuweisen.

Ich denke, es könnte hilfreich sein, auf eine Antwort zu verlinken, die dies auch gut erklärt. Es ist etwa boost::compressed_pairvon Logan Capaldo .

Dies kann Ihnen helfen :-) http://bytes.com/topic/c/insights/660463-sizeof-empty-class-structure-1-a

Die Größe einer leeren Klasse oder Struktur beträgt 1

Der Grund dafür ist die ordnungsgemäße Implementierung des Standards. Der C ++ - Standard sagt unter anderem, dass "kein Objekt dieselbe Adresse im Speicher haben darf wie jede 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, sodass sie eine Größe von 1 anstelle einer Größe von 0 haben und dann garantiert eine eindeutige Speicheradresse haben.

Die Zuweisung von 1 Byte für eine leere Klasse ist vom Compiler abhängig. Compiler müssen sicherstellen, dass sich Objekte an verschiedenen Speicherorten befinden, und sie müssen einem Objekt eine Speichergröße ungleich Null zuweisen. Hören Sie sich hier Notizen zu diesem Thema an: http://listenvoice.com/listenVoiceNote.aspx?id=27

Obwohl Compiler einer leeren Klasse eine Größe ungleich Null zuweisen, führen sie auch Optimierungen durch, wenn neue Klassen aus leeren Klassen abgeleitet werden. Informieren Sie sich über die Optimierung der leeren Basis in den Interviewfragen von ListenVoice zur C ++ - Programmierung.

Der Grund für eine Klasse ohne Datenelemente mit einer Größe von 1 Byte ist, dass dieser * starke Text * im Speicher gespeichert werden muss, damit eine Referenz oder ein Zeiger auf das Objekt dieser Klasse verweisen kann

leere Klasse - Diese Klasse enthält keinen Inhalt.

Jede Klasse, die nicht leer ist, wird durch ihren Inhalt im Speicher dargestellt.

Wie wird nun die leere Klasse im Speicher dargestellt? Da es keinen Inhalt gibt, der seine Existenz im Speicher nicht zeigen kann, aber eine Klasse vorhanden ist, ist es obligatorisch, seine Präsenz im Speicher zu zeigen. Um die Präsenz einer leeren Klasse im Speicher anzuzeigen, ist 1 Byte erforderlich.

Ich denke, das ist so, weil 1 Byte die kleinste Speichereinheit ist, die als Platzhalter verwendet werden kann, und keine Größe von Null angegeben werden kann, da es nicht möglich ist, ein Array von Objekten zu erstellen.

und die Sache, die Sie sagten "Das war ein wenig überraschend für mich, da ich erwartet hatte, dass es die Größe des Maschinenworts hat (32 Bit oder 4 Bytes)." gilt für die Referenzvariable (Macine-Wörter) vom Typ leer (), nicht für die Größe der Klasse selbst (die ein abstrakter Datentyp ist).

Ich denke, diese Frage ist nur von theoretischem Interesse, spielt aber in der Praxis keine Rolle.

Wie bereits von anderen erwähnt, schadet das Ableiten von einer leeren Klasse nicht, da dadurch kein zusätzlicher Speicher für den Basisklassenabschnitt verbraucht wird.

Wenn eine Klasse leer ist (was bedeutet, dass sie theoretisch keinen Instanzspeicher benötigt, dh keine nicht statischen Datenelemente oder virtuellen Elementfunktionen), können alle ihre Elementfunktionen genauso gut (und sollte) als statisch definiert werden. Es ist also nicht erforderlich, jemals eine Instanz dieser Klasse zu erstellen.

Fazit: Wenn Sie eine leere Klasse X schreiben, machen Sie einfach alle Elementfunktionen statisch. Sie müssen dann keine X-Objekte erstellen, und abgeleitete Klassen sind in keiner Weise betroffen.

#include<iostream>
using namespace std;


    class Empty { };
    int main()
    {
        Empty* e1 = new Empty;
        Empty* e2 = new Empty;

        if (e1 == e2)
            cout << "Alas same address of two objects" << endl;
        else
            cout << "Okay it's Fine to have different addresses" << endl;

        return 0;
    }

Ausgabe: Okay, es ist in Ordnung, unterschiedliche Adressen zu haben

Durch die Rückgabe von Größe 1 wird sichergestellt, dass die beiden Objekte nicht dieselbe Adresse haben.

Es ist ungleich Null, um sicherzustellen, dass die beiden unterschiedlichen Objekte unterschiedliche Adressen haben. Unterschiedliche Objekte sollten unterschiedliche Adressen haben, sodass die Größe einer leeren Klasse immer 1 Byte beträgt.

Ich denke, wenn die Größe einer leeren Klasse Null ist, bedeutet dies, dass sie nicht existiert. Damit es (Klasse) existiert, muss es mindestens 1 Byte haben, da dieses Byte die Speicher- / Referenzadresse ist.

Dies liegt an diesem Zeiger, obwohl der Zeiger (Ganzzahl) 4 Byte beträgt, sich jedoch auf einen Speicherplatz (eine Einheit) bezieht, der 1 Byte beträgt.