sondern
Zeile 7 = *pointer->operator [](0)=i;
sein

Bzw... Der vector ist ja noch leer, da kannst du das erste Element nicht beschreiben, gibt ja gar kein erstes... Musst halt erst was reinmachen, bevor du's verändern kannst.

Also in dem Sinne halt pointer->push_back( i );

Btw warum hast du den vector und einen Pointer auf eben diesen im selben Scope?

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

terminals.push_back(new double);

Die Zuweisung war dann doch so richtig hab die jedoh auf ..->at(i) geändert..

Das Problem war dass ich mir Klassen gearbeitet habe. Also:

Der Vecktor war Teil einer Klasse der an Weitere Klassen per Pointer übergeben wurde.

Der Pointer wurde jedoch benutzt bevor ich den in der anderen Klasse initialisiert wurde

hast du danach auch fleißig alle doubles mit delete entfernt?

*pointer->operator [](0)=i;

und hier nicht vergessen das i quasi als adresse benutzt wird, also der wert von i ist ein pointer auf einen double. ist das so gewollt?

und hier nicht vergessen das i quasi als adresse benutzt wird, also der wert von i ist ein pointer auf einen double. ist das so gewollt?

verstehe dass nicht ganz

ich dachte mit "*pointer->operator [](0)=i;" benutze ich den Inhaltsoperator "*" und kann den Inhalt auf den der Pointer Zeigt ändern.
Also würde ich beim abfragen des Wertes and dem Pointer den Wert i kriegen.

Das Mit den double Zeigern hab ich deswegen gemacht um in einer Klasse den Vektor zu haben(diese existiert nur ein mal)
und in den über 10000 anderen Klassenobjekten nur darrauf mit nem Zeiger zu verweisen um memory zu sparen.

Das Mit den double Zeigern hab ich deswegen gemacht um in einer Klasse den Vektor zu haben(diese existiert nur ein mal)
und in den über 10000 anderen Klassenobjekten nur darrauf mit nem Zeiger zu verweisen um memory zu sparen.

Und wofür brauchst Du double-Zeiger, wenn die anderen Klassen auf den vector zeigen sollen?

Ich versuche halt überall memory zu sparen da bei der Objektzahl die ich anlege dies zum Problem würde.

Ich versuche halt überall memory zu sparen da bei der Objektzahl die ich anlege dies zum Problem würde.

Wenn es diesen vector wirklich nur einmal gibt, dann hast du damit nichts gespart. Im Gegenteil, du hast mehr Speicher verbraten, weil du zu jedem double noch einen Zeiger angelegt hast. Das ist kompletter Blödsinn.

// ein mal vorhanden im Programm
class Managerklasse{
//...
vector <double*> vectorDing;
//...
};

// z.B. 100 Objekte im Programm
class KlasseDieDenZeigerNutzt{
      KlasseDieDenZeigerNutzt(vector <double*> *vectorDing);
      vector <double*> *m_VectorDing;
//...
};
// z.B. 10000000 Objekte im Programm
class KlasseDieEinenZeigerImVektorNutzt{
      KlasseDieEinenZeigerImVektorNutzt(double* zeiger);
      double *zeiger
//...
};

Wenn die voneinander abgeleitet währen ist klar dass ich mir den Mist auch sparen könnte.. die Klassen sind aber alle separat.

// ein mal vorhanden im Programm
class Managerklasse{
//...
vector <double> vectorDing;
//...
};

// z.B. 100 Objekte im Programm
class KlasseDieDenZeigerNutzt{
      KlasseDieDenZeigerNutzt(vector <double> *vectorDing);
      vector <double> *m_VectorDing;
//...
};
// z.B. 10000000 Objekte im Programm
class KlasseDieEinenZeigerImVektorNutzt{
      KlasseDieEinenZeigerImVektorNutzt(double* zeiger); 
      double *zeiger
//sehr gefährlich, willst du dich dann auch über den zeiger im vector bewegen? 
//oder ist das fix? wenn fix dann doch lieber ne reference, wenn du dich 
//bewegen willst würde ich gerne wissen woher du weißt wann du außerhalb des 
//vectors bist
//...
};

// z.B. 10000000 Objekte im Programm
class KlasseDieEinenZeigerImVektorNutzt{
      KlasseDieEinenZeigerImVektorNutzt(double* zeiger); 
      double *zeiger
//sehr gefährlich, willst du dich dann auch über den zeiger im vector bewegen? 
//oder ist das fix? wenn fix dann doch lieber ne reference, wenn du dich 
//bewegen willst würde ich gerne wissen woher du weißt wann du außerhalb des 
//vectors bist
//...
};

Hier ist vor allem gefährlich, daß der vector seinen Speicherbereich umorganisieren kann und dabei alle Referenzen, Iteratoren (sind häufig reine Zeiger) und Zeiger IN den vector ungültig werden können. (wenn die reservierte Kapazität nicht ausreicht für neu hinzukommende Elemente, reserviert er einen größeren Bereich, kopiert alles um und gibt den alten Bereich frei)

Ich würde vermutlich einen Zeiger auf den vector und den Index des beobachteten Elements unterbringen (hängt auch davon ab, wie langlebig die 'KlasseDieEinenZeigerImVektorNutzt'-Objekte sein werden).

Mit dem Zeiger selbst bewege ich mich nicht.. der wird von der Klasse ausschließlich ausgelesen, und nur von der Managerklasse einmal initialisiert.
Der Wert an diesem Zeiger wird auch nur über die Managerklasse gesetzt.

Ausserhalb des Vektors kann ich also nicht landen.. Die managerklasse passt da schon auf. Die Vektorgröße ist auch statisch.. da sollte nix passieren.

Mit Referenzen hab ich bislang aber nicht gearbeitet da ich eher der Zeiger Typ bin.
Was für ein Vorteil bringen mir denn Referenzen?

Hier ist vor allem gefährlich, daß der vector seinen Speicherbereich umorganisieren kann und dabei alle Referenzen, Iteratoren (sind häufig reine Zeiger) und Zeiger IN den vector ungültig werden können. (wenn die reservierte Kapazität nicht ausreicht für neu hinzukommende Elemente, reserviert er einen größeren Bereich, kopiert alles um und gibt den alten Bereich frei)

Ich würde vermutlich einen Zeiger auf den vector und den Index des beobachteten Elements unterbringen (hängt auch davon ab, wie langlebig die 'KlasseDieEinenZeigerImVektorNutzt'-Objekte sein werden).

dein Post kam kurz vor meinem

Danke für alle Hinweise..
Diese Lösung ist also besser wie ich sehe. Habe das mit dem Umorganisieren des Speichers nicht beachtet da ich den Einmal anlege und die Größe nie wieder ändere.
Werde aber diese Lösung wohl umsetzen da ich nicht weiß was die Zukunft bringt

Danke an alle!

Ich würde vermutlich einen Zeiger auf den vector und den Index des beobachteten Elements unterbringen (hängt auch davon ab, wie langlebig die 'KlasseDieEinenZeigerImVektorNutzt'-Objekte sein werden).

macht es dann überhaupt noch sinn sowas zu nutzen? schließlich sollte ja speicher gespart werden, zeiger auf vector+index = 64 bit = sizeof(double) dann kann man auch direkt den double wert dort ablegen.

reference vs. zeiger: du hast keine zeiger arithmetik und da, wie ich verstanden habdie nutzer klasse nicht iteriert und die vector größe statisch ist(kein umkopieren der daten) solltest du an dieser stelle wohl eher mit ner reference arbeiten.

also

class KlasseDieEinenZeigerImVektorNutzt{
      KlasseDieEinenZeigerImVektorNutzt(double d):zeiger(d){}; 
      double &zeiger

wobei eh die frage nach dem sin ist..doubles sind nicht so wirklich groß und selbst wenn du 100000 doubles speicherst hast du nicht mal nen mb belegt..ggf. gibt es andere stellen in deinem prog die du sinnvoller optimieren kannst..