Reihenfolge der Zerstörung für Array von Objekten

Question

class MyClass 
{ 
}; 

void foo 
{ 
    MyClass arr[10]; 
} 

Ich möchte die Reihenfolge der Zerstörung von Array-Objekten wissen, wenn die Funktion zurückkehrt.

Ich las es effektiver, C++ darüber und es sagt, dass destructor in umgekehrter Reihenfolge, die der Konstruktor, um wie folgt aufgerufen werden:

for(int i = 9 ; i >= 0 ;i--) 
{ 
    arr[i].MyClass::~MyClass(); 
} 

Kann jemand mir sagen, der Grund dafür?

Answer 1

Die von destructor Invokation Filosophie von C++ Fortsetzung der umgekehrten Reihenfolge ist. Wenn gestapelte Objekte zerstört werden, geschieht dies in umgekehrter Reihenfolge, um RAII zu erleichtern. Obwohl das für Array-Elemente nicht wirklich notwendig ist (sie sind alle mit den Standardkonstruktoren konstruiert und jede Reihenfolge von Konstruktion/Zerstörung würde genügen), wird das gleiche mit ihnen getan, nur aus Gründen der Konsistenz.

Answer 2

Vielleicht in dem die Reihenfolge der Objekte, die das Array bilden, sind auf dem Stapel abgelegt. Wie auch immer, außer Neugierde kann ich mir keinen Grund vorstellen, sich um den Zerstörungsbefehl zu sorgen.

Answer 3

Die Informationen, die Sie sich beziehen sind in effektiver C++ auf Objekte angewendet wird, die ein paar anderen Objekt enthalten, wie in diesem Fall:

class Foo { 
    private: 
    Bar bar_1; 
    Bar bar_2; 

    public: 
    Foo() : bar_1(), bar_2() {} 
}; 

Im obigen Beispiel, haben Sie bar_1 zuerst konstruiert , gefolgt von bar_2. Wenn ein Objekt der Klasse Foo dann zerstört wird, wird bar_2 zuerst zerstört, dann bar_1. Darauf bezieht sich Scott Meyers.

Aus der Sicht der Klasse wäre ein Array von Balken ein anderes Objekt, das der Compiler zerstören muss, so dass die Reihenfolge der Zerstörung beeinflusst wird, wenn das Array im Kontext der anderen Objekte in der Klasse zerstört wird.

Wie zu welcher Reihenfolge die Elemente eines Arrays zerstört werden, würde ich nicht zu wundern, wenn die Umsetzung abhängig ist. Hier spielt auch die Optimierung eine Rolle (zum Beispiel kann ein POD-Array einfach dadurch zerstört werden, dass es seinen Speicher freigibt, wie es ein Objekt sein kann, das ausschließlich aus PODs besteht). All dies kann die Reihenfolge beeinflussen, in der die Elemente eines Arrays zerstört werden.

würde ich interessieren zu sehen, warum Sie den Auftrag tun müssen wissen, in dem die Array-Elemente zerstört werden (abgesehen von technischen Neugier, das ein triftiger Grund IMHO wäre). Wenn zwischen den Elementen des Arrays Abhängigkeiten bestehen, muss die Datenstruktur möglicherweise überprüft werden.

Answer 4

Jede Bestellung würde wirklich tun. Die zwei offensichtlichen Wahlmöglichkeiten sind natürlich in der Reihenfolge oder in umgekehrter Reihenfolge. In diesem Fall dachte jedoch keiner der Compiler-Hersteller, dass es sich lohnen würde, diese Implementierung abhängig zu machen. Daher wurde die Wahl getroffen, um die umgekehrte Reihenfolge zu verlangen (wie scharf angegeben, Erweiterung der üblichen LIFO-Verhalten)

Answer 5

Sie zitieren nicht, welche Seite in Meyer's Buch Sie beziehen, aber ich stimme mit Timo Geusch, dass die Erklärung klingt wie es sich bezieht, dass Konstruktoren und Destruktoren entsprechend der Vererbung aufgerufen werden.

Für eine Reihe von Objektinstanzen, dass die Reihenfolge Objekte zerstört werden, ist die Umkehrung der Reihenfolge des Aufbaus. Dies ist leicht zu überprüfen, wie der folgende Code zeigt. Eine Klassenvariable verfolgt die Gesamtzahl der erstellten Instanzen und ein Datenelement für jedes Objekt verfolgt seine eigene Nummer. Der Konstruktor und der Destruktor geben eine Nachricht aus, sodass wir bei der Ausführung genau sehen können, was wann passiert.

Der Testcode gibt die Anzahl der Objekte von 0 bis 9 beim Konstruieren aus und dann von 9 bis 0, wenn die Instanzen zerstört werden. (Dies wurde mit g++-4.2 unter Mac OS X getestet)

#include <iostream> 

class MyClass 
{ 
public: 

    MyClass() 
    { 
     mCounter = kInstanceCount++; 
     std::cout << "+++ MyClass() " << mCounter << std::endl; 
    } 

    ~MyClass() 
    { 
     std::cout << "--- MyClass() " << mCounter << std::endl; 
    } 

private: 
    unsigned   mCounter; 
    static unsigned  kInstanceCount; 
}; 

unsigned MyClass::kInstanceCount = 0; 

int main() 
{ 
    MyClass arr[10]; 
    return 0; 
} 

Sie müßten den C++ Standard überprüfen, da ich nicht 100% sicher bin, dass dies nicht eine Implementierung Detail (wie es oft der Fall ist) In diesem Fall möchten Sie sich nicht auf dieses Verhalten verlassen.

Beachten Sie auch, dass es nicht so üblich ist, ein stackbasiertes Array von tatsächlichen Objektinstanzen zu erstellen. Sie verwenden eher std::vector oder verwenden möglicherweise Smartpointer für Heap-allocated-Objekte.