Zeiger

Julia_Prog

Kein Problem:

class Haeuser
{
private:

      string name;
public:
      Haeuser(string pname)
      string get_Name() const (return name;)
}

Haeuser::Haeuser (string pname)
{
   name=pname;
}

class Kostendaten

private:

map<Haeuser,Straßen> test;

public:

map<Haeuser,Straßen> test2 () {return test;}

class Berechnung

private:
Kostendaten *Kosten;

public:

void bestimme_Kosten();

Berechnung::Berechnung(Kostendaten *pKosten) : Kosten(pKosten) 
{

}

void Berechnung:bestimme_Kosten()
{
   map<Haeuser,Straßen>:iterator berechnung=Kosten->test2().begin();

//HIER KNALLTS :/
cout<<berechnen->first.get_Name();

}

die Variante funktioniert:

void Berechnung:bestimme_Kosten()
{
   map<Haeuser,Straßen> test_1=Kosten->test2();

   map<Haeuser,Straßen>:iterator berechnung=test_1.begin();

cout<<berechnen->first.get_Name();
}

aber ist doch irgendwie doof, nochmal alles zwischen zu kopieren

SeppJ

Jetzt zeig bitte noch, wie du das Berechnung Objekt erzeugst.

Julia_Prog

ich habe ja am Anfang auch geglaubt, dass ich bloß vergessen habe die Kostendaten zu initialisieren. Wenn ich das Zwischenkopiere funktioniert es aber problemlos... da steht dann auch was in der Map drin... so wie es sein muss

nur dann dachte ich, dann brauch ich keinen Zeiger übergeben, sondern kann gleich die Kostendaten als Kopie übergeben...

//hier liest er ne Menge Werte aus der Datei ein.. die gebe ich dann noch aus, um zu sehen, ob er das macht
Kostendaten test;
test.Kostendaten_einlesen();

Berechnung neu(&test);
neu.bestimme_Kosten();

Julia_Prog

Meine Frage ist ja, warum funktioniert die 2. Variante und die 1. nicht? Daten sind ja drin...

Das

map<Haeuser,Straßen> test2 () {return test;}

gibt auf jeden Fall einen Fehler, wenn du es nicht zwischenspeicherst, da bei jedem Aufruf eine Kopie erzeugt wird. Das

if( k.test2().begin() != k.test2().end() )

würde dann z.B. die Iteratoren zweier verschiedener Maps vergleichen.

Julia_Prog

Ich habe ja auch versucht, davon die Adresse oder Referenz zurück zu geben:

map<Haeuser,Straßen> *test2 () {return &test;}

map<Haeuser,Straßen> &test2 () {return test;}

wie kann ich denn sicherstellen, dass ich immer auf das selbe Ergebnis zugreife?

Ich dachte außerdem, ich rufe die Methode ja auch nur einmal auf, ich lege ja den Iterator da drauf oder nicht??

Nach dieser Zeile

map<Haeuser,Straßen>:iterator berechnung=Kosten->test2().begin();

ist der Iterator auch gelich nicht mehr zu gebrauchen, da die Map nicht mehr existiert.

Mit der Referenz oder dem Pointer müsste es aber funktionieren. Da ist dann noch ein anderer Fehler vorhanden.

Julia_Prog

hm vielleicht muss ich auch noch die Methode in der Klasse Häuser anpassen...

warum ist denn der iterator nicht mehr zu gebrauchen? Damit ich noch was lerne

Julia_Prog schrieb:

warum ist denn der iterator nicht mehr zu gebrauchen?

manni66 schrieb:

ist der Iterator auch gelich nicht mehr zu gebrauchen, da die Map nicht mehr existiert

Julia_Prog

Auch wenn ich nicht so wirklich verstanden habe, warum das mit dem Iterator dann nicht mehr funktioniert, läuft jetzt wenigstens das Programm.

Ich danke für die Hilfe.

Caligulaminus

map<Haeuser,Straßen> test2 () {return test;}

erzeugt eine Kopie für die rufende Funktion.
Mit

map<Haeuser,Straßen>::iterator berechnung=Kosten->test2().begin();

holst Du dir dann einen Iterator auf diese Kopie.
Da Du aber die Kopie nirgendwo ablegst ist sie sofort danach wieder perdu, und dein Iterator zeigt ins Nirvana.

Alternative:

map<Haeuser,Straßen> & test2 () {return test;}

Und

map<Haeuser,Straßen> &xyz=Kosten->test2();
map<Haeuser,Straßen>::iterator berechnung=xyz.begin();

Keine Kopie, kein Zeiger.

Wobei - ich bin mir nicht sicher, ob wir dann nicht wieder über das private: stolpern. Versuchs halt mal...

Th69

So wie ich den Code verstehe, sollen die Daten ja nur zur Berechnung ausgelesen werden.
Daher wäre ein Umschreiben des Codes auf "const correctness" sowieso am besten, denn interne Daten sollte man möglichst nicht einfach per "non-const reference" ändern dürfen.

Hier also mein Vorschlag:

map<Haeuser,Straßen> my_map;

const map<Haeuser,Straßen> & Map () const { return my_map; }

Und der Zugriff dann von außen nur über "const_iterator":

const map<Haeuser,Straßen> & xyz = Kosten->Map();
for(map<Haeuser,Straßen>::const_iterator it = xyz.begin(); it != xyz.end; ++it)
{
  // ...
}

Evtl. noch einen Aliasnamen in der Klasse anlegen, z.B.

typedef map<Haeuser,Straßen> street_map;
typedef street_map::const_iterator street_const_iterator;

und dann nur noch damit arbeiten.