class Enemy
{
    public:
    sf::Sprite *Barrel;
    Enemy(const Enemy &Origin);
    ~Enemy();
};

Enemy::Enemy(const Enemy &Origin) // Kopierkonstruktor
{
    if (/* je nach Gegner */)
       Barrel = new sf::Sprite(Image);
    else
       Barrel = NULL;
}

Enemy::~Enemy() // Destruktor
{
   // Ausgabe 2 (Iterator)..
   // Ausgabe 3 (Member von *this)..
   delete Barrel;
}

// global
std::vector<Enemy> Enemies;
std::vector<Enemy>::iterator it;

// in einer Funktion
   it = ThisMap->Enemies.begin() + /* ... */;
   // Ausgabe 1 (Iterator)..
   ThisMap->Enemies.erase(it);

Wenn ich mir die Klassenmember des Iterators (bei Ausgabe 1) ansehe, stimmt noch alles. Dann lösche ich diese Klasse mit erase(), und es wird automatisch der Destruktor Enemy::~Enemy() aufgerufen. Dort (Ausgabe 2) habe ich jedoch völlig andere Werte für den Iterator, wie kann das sein? Ich denke, zuerst wird die Klasse destruiert und erst dann aus dem Vektor entfernt, geschieht das umgekehrt?...
Wenn ich dann schlussendlich noch Ausgabe 3 anschaue und im Destruktor die klasseneigenen Member betrachte, sind es wiederum andere Werte, und zwar die des letzten Vektor-Elementes... Das würde heissen, der Destruktor wird vom letzten Element aufgerufen, was ja nur durch erase() oder pop_back() - die ich aber nicht auf das letzte Element anwende - möglich wäre. Das Merkwürdige daran ist, das letzte Element im Vektor ist nachher immer noch das gleiche.
Weil immer der Destruktor des letzten Elementes aufgerufen wird, wird delete ja mehrfach angewandt, was zu der Zugriffsverweigerung führt.

Ich kann es mir jedoch nicht erklären, wieso immer der Destruktor des letzten Elementes aufgerufen wird, zumal ich die Iteratoren ja noch ausgeben lasse (bei Ausgabe 1 stimmen die Werte noch). Geschieht da intern im Vektor etwas, oder woran könnte das liegen?

Nexus schrieb:

Wenn ich mir die Klassenmember des Iterators (bei Ausgabe 1) ansehe, stimmt noch alles. Dann lösche ich diese Klasse mit erase(), und es wird automatisch der Destruktor Enemy::~Enemy() aufgerufen. Dort (Ausgabe 2) habe ich jedoch völlig andere Werte für den Iterator, wie kann das sein? Ich denke, zuerst wird die Klasse destruiert und erst dann aus dem Vektor entfernt, geschieht das umgekehrt?...

wenn du tatsächlich auf so ein wissen angewiesen bist, dann ist die primäre informationquelle für dich der standard. dort findest du spezifikationen zu allen memberfunktionen und dem interface der standardcontainer. und wenn dort etwas nicht definiert ist (so wie, was geschieht zuerst, der iterator invalidiert oder das element gelöscht), dann ist das ein hinweis an dich, deinen code nicht von einer bestimmten reihenfolge abhängig zu machen (weil es überall anders aussehen könnte).

für dein verständnisproblem hilft es wahrscheinlich, dir vorzustellen, wie vector intern normalerweise aufgebaut ist: als einfach zusammenhängender, mit new allozierter, speicher.
dann stell dir vor, du machst das manuell:

typedef Enemy* iterator;

Enemy* vector = new Enemy[100];
iterator it = vector + 20;

wie würdest du nun das element, auf den der iterator zeigt, löschen?
du müsstest es aus dem array herausnehmen, und letztendlich alle anderen elemente, die nach dem element, auf das der iterator zeigt, kommen, eines nach hinten kopieren. der iterator könnte die ganze zeit auf dieselbe stelle zeigen.
wenn du aber alle elemente "eins nach hinten kopieren" musst, musst du alle elemente irgendwann zerstören und sie an einer neuen position (eins dahinter) wieder zum leben erwecken.

wenn du mit dynamischen speicher arbeitest, solltest du smart-pointer verwenden (hier: boost::shared_ptr oder std::tr1::shared_ptr), damit du dir das problem mit dem "doppelten delete" ersparst und exceptionsicher bist. ansonsten schau dir die Regel der großen Drei "rule of the big three" an, und implementiere deinen copy-konstruktor richtig!

struct Foo
{
   Sprite* Barrel;
   Foo (Foo const& other)
   {
      Barrel = new Sprite(other.Barrel);
   }
   Foo& operator = (Foo const& other)
   {
      Foo tmp(other);
      swap (Barrel, tmp.Barrel);
      return *this;
   }
   ~Foo ()
   {
      delete Barrel;
   }
};

//und mit shared_ptr sieht es so aus
struct Enemy
{
   std::tr1::shared_ptr<Sprite> Barrel;
};

Mit "Klassen destruieren" hab ich mich falsch ausgedrückt, ich meinte natürlich Instanzen.

So, wie du das Prinzip mit dem Löschen der dahinterstehenden Elemente und dem folgenden Neu-Erstellen eine Position davor erklärt hast, kann das aber nicht stimmen. Das sehe ich ja nur schon daran, dass der Destruktor nur ein einziges Mal (nicht für alle Elemente dahinter) aufgerufen wird. Er wird zwar aufgerufen, wieso das betroffene Element allerdings das letzte ist, ist mir nach wie vor ein Rätsel. Ich hab den Iterator mehrfach überprüft, er zeigt sowohl vor als auch nach dem Aufruf von erase() auf das richtige Element. Es wird auch das richtige Element aus dem Vektor entfernt, jedoch nicht der richtige Destruktor aufgerufen...

Zu erase() finde ich nirgends genaue Informationen, wie der Algorithmus im Detail funktioniert. Überall ist nur beschrieben, wie er anzuwenden ist, und das mit einfachen Beispielen. Und im Quellcode der Datei "vector" finde ich mich kein bisschen zurecht

Die Reihenfolge der Zuweisung ist unbestimmt (wird aber wohl immer aufsteigend sein, weil der Zielbereich ja überlappen kann). Die Reihenfolge der Destruktoraufrufe ist ebenfalls unbestimmt (das geht nur, weil Destruktoren von Elementen keine Exceptions werfen dürfen), wird aber wohl vom höheren Index aus erfolgen: in umgekehrter Reihenfolge der Erzeugung - beginnend also mit dem letzten Element.
Warum wird nicht erst zerstört und dann kopiert (und nochmal zerstört)? Sowohl Zuweisungsoperator als auch Copyctor von Elementen dürfen Exceptions werfen - wirft ein Copyctor eine Exception hätte unser vector aber plötzlich ein Loch: das darf nicht sein.

Es werden also tatsächlich nicht genau die Elemente zerstört, auf die die übergebene Sequenz verweist (wenn sie sich nicht zufällig am Ende befindet).