vector problem..

hatte ja vorhin schon mit push_back elemente reigelegt, also:

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

Badestrand

Der einzige Unterschied zwischen at(..) und [..] ist, so glaube ich jedenfalls, dass at(..) prüft, ob eine Index-Überschreitung vorliegt. Aber naja, wenns jetzt funktioniert

.at prüft das zwar zur Laufzeit, das heißt aber nicht das das Programm dann störungsfrei ist. Man bekommt bei einer Verletzung der Bereichsgrenze eine out-of-range Exception an den Kopf geschmissen. Die Bereichsgrenzen zu prüfen ist also IMMER Pflicht.

ConfusedGuy

mir macht noch angst das du zeiger auf doubles verwendest..ist es ggf. nicht besser die doubles direkt in den vector zu schieben?

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.

LordJaxom

vectorix schrieb:

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?

wiederrum andere Klassen haben wiederrum hunderte Objekte die auf die Zeiger im Vektorzeiger zeigen

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

MFK

vectorix schrieb:

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.

jetzt bin ich verwirrt
hirzu möchte ich mal kurz die Topologie der drei Klassen beschreiben
Die klassen sind dabei nicht voneinander abgeleitet..

// 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.

ConfusedGuy

da spricht nix dagegen die doubles dann direkt in den vector zu schieben.

// 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
//...
};

CStoll

ConfusedGuy schrieb:

// 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).

wenn ich die double Werte direkt in den Vektor schiebe müsste ich in der Klasse "KlasseDieEinenZeigerImVektorNutzt" den Vektorzeiger übergeben statt den double Zeiger.
Würde auch gehen, nur müsste ich noch im selben Objekt definieren welches Vektorelement nun zu gebrauchen ist.

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!

ConfusedGuy

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..