Warum belegen C++ - Klassen ohne Membervariablen Platz?

Question

Ich fand, dass MSVC und GCC-Compiler mindestens ein Byte pro Klasseninstanz zuweisen, selbst wenn die Klasse ein Prädikat ohne Membervariablen (oder nur mit statischen Membervariablen) ist. Der folgende Code veranschaulicht den Punkt.

#include <iostream> 

class A 
{ 
public: 
    bool operator()(int x) const 
    { 
     return x>0; 
    } 
}; 

class B 
{ 
public: 
    static int v; 
    static bool check(int x) 
    { 
     return x>0; 
    } 
}; 

int B::v = 0; 

void test() 
{ 
    A a; 
    B b; 
    std::cout << "sizeof(A)=" << sizeof(A) << "\n" 
      << "sizeof(a)=" << sizeof(a) << "\n" 
      << "sizeof(B)=" << sizeof(B) << "\n" 
      << "sizeof(b)=" << sizeof(b) << "\n"; 
} 

int main() 
{ 
    test(); 
    return 0; 
} 

Ausgang:

sizeof(A)=1 
sizeof(a)=1 
sizeof(B)=1 
sizeof(b)=1 

Meine Frage ist, warum Compiler braucht es? Der einzige Grund, den ich finden kann, ist sicherzustellen, dass alle Mitglieds-Var-Zeiger unterschiedlich sind, so dass wir zwischen zwei Mitgliedern vom Typ A oder B unterscheiden können, indem wir Zeiger auf sie vergleichen. Aber die Kosten dafür sind ziemlich streng im Umgang mit kleinen Behältern. In Anbetracht der möglichen Datenausrichtung können wir bis zu 16 Bytes pro Klasse ohne vars (?!) Erhalten. Angenommen, wir haben einen benutzerdefinierten Container, der normalerweise einige int-Werte enthält. Betrachten Sie dann ein Array solcher Container (mit etwa 1000000 Mitgliedern). Der Overhead wird 16 * 1000000 sein! Ein typischer Fall, in dem dies passieren kann, ist eine Containerklasse mit einem Vergleichsprädikat, das in einer Membervariablen gespeichert ist. Bedenkt man außerdem, dass eine Klasseninstanz immer etwas Platz einnehmen sollte, welche Art von Overhead sollte man beim Aufruf von A() (value) erwarten?

Answer 1

Es ist notwendig, eine Invariante aus dem C++ - Standard zu erfüllen: Jedes C++ - Objekt des gleichen Typs muss eine eindeutige Adresse haben, um identifizierbar zu sein.

Wenn Objekte keinen Platz beanspruchten, würden Elemente in einem Array die gleiche Adresse haben.

Answer 2

Alle vollständigen Objekte müssen eine eindeutige Adresse haben; Sie müssen also mindestens ein Byte Speicher belegen - das Byte an ihrer Adresse.

Ein typischer Fall, in dem es vorkommen kann, ist eine Containerklasse mit einem Vergleichsprädikat, das in einer Membervariablen gespeichert ist.

In diesem Fall können Sie die leere Basisklasse Optimierung verwenden: eine Basis subobject die gleiche Adresse wie das komplette Objekt haben dürfen, dass es Teil, so dass keine Speicherung in Anspruch nehmen können. Sie können also das Prädikat einer Klasse als (möglicherweise private) Basisklasse und nicht als Mitglied hinzufügen. Es ist etwas fummeliger als ein Mitglied, aber sollte den Overhead beseitigen.

Welche Art von Overhead sollte erwartet werden, wenn A() (Wert) aufgerufen wird?

Der einzige Overhead im Vergleich zum Aufruf einer Nicht-Member-Funktion wird das zusätzliche this Argument übergeben. Wenn die Funktion inline ist, sollte dies eliminiert werden (wie dies im Allgemeinen der Fall ist, wenn eine Mitgliedsfunktion aufgerufen wird, die nicht auf Mitgliedsvariablen zugreift).

Answer 3

Im Grunde ist es ein Wechselspiel zwischen zwei Anforderungen:

• Zwei verschiedene Objekte des gleichen Typs an einer anderen Adressen sein muss.
• In Arrays ist möglicherweise kein Abstand zwischen Objekten vorhanden.

Beachten Sie, dass die erste Bedingung allein nicht ungleich Null Größe erfordert: Gegeben

struct empty {}; 
struct foo { empty a, b; }; 

die die erste Anforderung leicht mit einer Null-Größe a gefolgt von einem einzelnen Füllbyte erfüllt werden könnte, um erzwingen Sie eine andere Adresse, gefolgt von einer Nullgröße b. Angesichts der Tatsache

empty array[2]; 

, die nicht mehr funktioniert, weil eine Polsterung zwischen den verschiedenen Objekten empty[0] und empty[1] würde nicht erlaubt sein.

Answer 4

Es gibt bereits ausgezeichnete Antworten, die die Hauptfrage beantworten. Ich möchte auf die von Ihnen geäußerten Bedenken eingehen:

Aber die Kosten dafür sind bei kleinen Behältern sehr hoch. In Anbetracht der möglichen Datenausrichtung können wir bis zu 16 Bytes pro Klasse ohne vars (?!) Erhalten. Angenommen, wir haben einen benutzerdefinierten Container, der normalerweise einige int-Werte enthält. Betrachten Sie dann ein Array solcher Container (mit etwa 1000000 Mitgliedern). Der Overhead wird 16 * 1000000 sein! Ein typischer Fall, in dem dies passieren kann, ist eine Containerklasse mit einem Vergleichsprädikat, das in einer Membervariablen gespeichert ist.

Vermeidung der Kosten für A

halten Wenn alle Instanzen eines Behälters hängen vom Typ A, dann gibt es keine Notwendigkeit, Fälle von A im Behälter zu halten. Der Overhead, der mit der Größe A ungleich Null verknüpft ist, kann vermieden werden, indem einfach eine Instanz von A auf dem Stapel erstellt wird, wenn dies erforderlich ist.

nicht die Kosten der Holding zu vermeiden, in der Lage, A

Sie gezwungen werden kann, einen Zeiger auf A in jedem Fall des Behälters zu halten, wenn A von polymorphen zu erwarten ist. Für einen solchen Behälter steigen die Kosten jedes Behälters um die Größe eines Zeigers. Ob es Membervariablen in der Basisklasse A gibt oder nicht, spielt für die Größe des Containers keine Rolle.

Auswirkungen der sizeof A

In jedem Fall sollte die Größe einer leeren Klasse auf den Speicherbedarf des Behälters keinen Einfluss haben.