Pointer auf Vector-Position

Hallo zusammen,

ich habe folgendes Problem:
- habe ein vector-Objekt
- setze einen Zeiger auf eine Position dieses vectors
- lösche eine Stelle in dem vector (mit erase)
- hab dann das Problem, dass der Zeiger eine Stelle im vector weiter gerutscht ist

Hier mal mit Code:

vector<long> vectorListe;
vectorListe.push_back(1);
vectorListe.push_back(2);
vectorListe.push_back(3);
vectorListe.push_back(4);
long *test = &vectorListe[2];   // Zeiger test zeigt auf Zahl 3

vectorListe.erase(this->vectorListe.begin()+1);  // 2. Eintrag löschen (Zahl 2) 
cout << test << endl;                            // liefert 4 zurück (FALSCH)

Kann mir jemand bei diesem Problem weiterhelfen? Kann ich das irgendwie lösen, sodass der Zeiger noch immer auf die Zahl 3 zeigt? Wenn ja, wie?

Vielen Dank und liebe Grüße,

ALEX

Naja, dafür ist erase doch da... Was vorher da war, soll nach dem erase nicht mehr da sein! Das einzige was du machen kannst, ist, dass du im vector nur Zeiger auf int's speicherst und dann deinen zeiger auf das zeigen lässt, auf das der Zeiger im Vektor zeigt. Dann hast du aber wieder das Problem mit der lebenszeit... Wer soll am Ende dafür zuständig sein, das zu löschen? Und wenn ich anfange, mit einem Smartpointer auf int's zu zeigen, mache mir Gedanken, ob das wirklich Sinn ergibt.

Grüße,
Michael

freaky

Ist auch klar. Du löschst ein Element in dem Vector, womit aufgerückt wird.

Element1 --Kette-- Element2 --Kette-- Element3 --Kette-- Element4 --Kette-- NULL

So nun löscht du das 2. Element wo mit eine Lücke entsteht.

Element1 --Kette-- --Kette-- Element3 --Kette-- Element4 --Kette-- NULL

Nun wird aufgerückt

Element1 --Kette-- Element3 --Kette-- Element4 --Kette-- NULL

Und dein Zeiger zeigt auf das 3. Element, womit durch die Löschung des 2. Element, das 3. Element den Platz einnimmt, aufgerückt wird und dein Zeiger automatisch auf Element4 zeigt.
Erstmal

vectorListe.erase(this->vectorListe.begin()+1);

Mach da das this-> weg, brauchst du nicht.
Und nun schreib unter diese Zeile

test--;

Somit zeigt der Zeiger auf das Element das eins hintendran ist.
Das gleiche kann man auch mit Arrays machen.

#include <iostream>

int main()
{
    int array[5] = {1,2,3,4,5};
    int *test = &array[0];
    for(int i = 0; i < 5; i++)
    {
        std::cout << *test;
        test++;
    }
}

Hier zeigt am Anfang der Zeiger auf das 1. Element und wandert dann bis zum 5.
Ein Array könnte man sich z.B. so vorstellen.

| 5 | <- 4
| 4 | <- 3
| 3 | <- 2 //...
| 2 | <- 1 //test++
| 1 | <- 0 //Hier zeigt der Zeiger zuerst drauf

Durch das ++ wandert er dann durch den Speicher.
Hoffe das war genug Erklärung.
Mit freundlichen Grüßen : FreakY

Skym0sh0

warum ist doch alles richtig

der array index geht von 0 bis n-1

du zeigst auf die zahl 3, löschst dann die 2 und zeigst dann auf die 4, ist doch logisch

Hi!

Natürlich ist das logisch und das macht auch Sinn, auf jeden Fall. Ich hätte es trotzdem gerne anders, sodass der Zeiger noch immer auf denselben Wert zeigt und nicht weiter rutscht :-). Klar macht das alles was es tun soll.

Werde jetzt mal ausprobieren, den Zeiger zu dekrementieren, mal sehn was dabei rauskommt. Vielen Dank erstmal!

Liebe Grüße,

ALEX

Die Zahl ist nicht mehr im Vektor gespeichert, da wirst du durch dekrementieren und inkrementieren nichts erreichen. Und dein Zeiger rutscht ja nicht weiter, nur die Werte rutschen unter deinem Zeiger durch!
PS: Wenn du uns sagst, was du ultimativ mit der ganzen Sache anstellen möchtest, könnten wir dir ja eventuell Vorschläge für Alternativen machen.

Es geht darum, dass ich in einer Schleife durch einen vector iteriere. Es ist ein vector vom Typ "Ecke". Diese selbst geschriebene Klasse besitzt als Attribute zwei Zeiger auf weitere Objekte (eckeE und eckeF) vom Typ Ecke. Ich möchte jetzt beispielsweise in meiner Schleife den Zeiger eckeE der Ecke 1 meines vectors auf eine andere Ecke in diesem vector setzen (z.B. Ecke 4). Und diese Referenz soll auf exakt dieser Ecke bleiben und nicht auf die 5.Ecke zeigen, wenn ich die 3. Ecke auf meinem vector entferne. Verständlich?

Liebe Grüße,

ALEX

Sooo genau hab ich das jetzt nicht verstanden, aber sowas könnte funktionieren:

std::vector< Ecke > Ecken;
std::vector< unsigned int > EckenIndizes;

// Ecke hinzufügen
Ecken.push_back( Ecke() );
EckenIndizes.push_back( Ecken.size()-1 );

// Zeiger auf x-te Ecke erstellen
Ecke* some = &Ecken[EckenIndizes[x]];

// Ecke aus der Liste der "aktiven Ecken" löschen
EckenIndizes.erase(...);

Braunstein

Man könnte doch auch Pointer auf Ecke speichern und sich die merken. Dann ist man zwar für das Erzeugen und Aufräumen selbst verantwortlich hat aber immer schön die Zeiger auf die Elemente.

So gedachte ich doch auch meinen Vorschlag zu verwenden, nur dass halt beim löschen der aktiven Ecken nicht wirklich die Ecken gelöscht werden, sondern nur die Verweise darauf aus dem Index-Array. Wenn man das beherzigt, kann man doch die Zeiger auf die Ecken speichern (Bis halt der Ecken-Vektor zerstört wird).

Fellhuhn

Dann speicher Pointer auf Ecken in dem Vector, denn wenn du deinen vector vergrößerst, werden irgendwann auch alle Elemente umkopiert und stehen so an anderen Speicherstellen. Würdest also auch an anderen Stellen Probleme bekommen.

Und da du, schätze ich jetzt einfach mal, keinen Kopierkonstruktor für deinen Typ Ecke definiert hast, wird das ganze mit dem Herumkopiere im vector eh kritisch.

AAAAAAAAAAAAAAAAAHHHHHHHHH. Wie konnte ich das gerade so total übersehen? -.- Schaltet sich mein Hirn irgendwie aus, wenn ich den Browser starte? -.- Das war natürlich der dümmste Vorschlag, den ich überhaupt nur machen konnte.