C++ Liste ausgeben -> Ausgabe nur speicheradresse

[jensa]

Der Code meines Iteratorteils:

// Irgendwo in einer Funktion
std::list<Konto*> objList; // Die Liste mit den Objekten.
objList = meinKunde.getMeineKonten();

ostream_iterator<Konto*> outIter(cout, "\n"); // Objekte getrennt durch neue Zeile.
copy(objList.begin(), objList.end(), outIter); // Liste auf die Konsole "kopieren".

getMeineKonten() liefert einen Pointer auf Konten zurück
(list<Konto*> Kunde::getMeineKonten(){return meineKonten;};)

Und in meineKonten wird mittels
setMeineKonten() ein Pointer auf eine kontenliste gestartet.

Der Komplette Quellcode im Anhang.

Lieder bekomme ich nicht die Kontonummern zurück sondern lediglich eine Speicheradresse der konten:

Beispielprogramm zur Navigation einer 1:n Assoziation
Konten des Kunden: Kurt
Konten: 0x804b020
0x804b030
0x804b040

bank_cpp.zip

hoffe ihr könnt mir helfen wie ich mir die Kontonummer ausgeben lassen kann.

[Firefighter]

Also was mir beim überfliegen aufgefallen ist, warum halten deine Kunden die Konten?Eigentlich sollte doch eine Bank alle Konten+Kunden halten. Und die Bank übt dann diverse Operationen auf Konten+Kunden aus. Das du nur die Adresse deiner Konten angezeigt bekommst, liegt daran, das du die Iteratoren auf die Elemente ausgibst, und diese halten halt nur die Adressen

Edit: Bau dir entweder eine Mehtode zum ausgeben der Konten oder überlade den Ausgabeoperator bzw Indexoperator.

[jensa]

bezüglich der Beziehungen bank-kunde-konto ist halt für mich eine Übung n:n verbindungen abzubilden.

sorry,
inwiefern könnte ich den Operator überladen oder mithilfe was für einer MEthode könnte ich es mir ermöglichen?

heißt wenn ich

std::list<Konto*> objList; // Die Liste mit den Objekten.
	objList = meinKunde.getMeineKonten();

	ostream_iterator<Konto*> outIter(cout, "\n"); // Objekte getrennt durch neue Zeile.
	copy(objList.begin(), objList.end(), outIter); // Liste auf die Konsole "kopieren".

müsste ich ostream_iterator<Konto*> outIter(cout << meinKonto.getNummer, "\n");
sagen?
in java würde es ja einfach mit dem durchiterieren möglich sein jedoch unter cpp aufgrund der pointer halt leider nur die adresse.:/

gruß jensa

[Tachyon]

Du kannst das nicht direkt machen, sondern musst die Pointer erst wieder in Referenzen transformieren. Das geht mit std::transform:

template<typename T>
T& dereference(T* ptr){ return *ptr; }

//...

std::transform(objList.begin(), objList.end(), std::ostream_iterator<Konto>(std::cout), dereference<Konto>);

[Firefighter]

Also ich würde eine private Methode schreiben die es ermöglicht alle Konten auszugeben, diese private Methode rufst du dann nur noch in deinem operator auf, oder du machst in deinem operator wie in der Methode und codest die Ausgabe hart rein.

Eine Idee wie ich die Beziehungen machen würde:

class Konto
{
  private: //irgendwelche wichtigen Daten,Kontonummer...usw

  public:
};

class Kunde
{
   private:
    Konto* meinkonto; //jeder Kunde bekommt ein eigenes Konto

  public:
  Kunde():meinkonto(new Konto){}
};

class Bank
{
  private: 
    std::vector<Kunde*> die_kunden;
  public:
   //Methoden für die Ausgabe der Daten, setzt voraus das du noch ein paar zugriffsmethoden in deinen anderen Klassen hast.
};

Also das wäre meine Idee, ob das die beste ist, ist natürlich wie immer dahin gestellt.

[drakon]

Was spricht den dagegen da ganz normal mittels einer for - Schlaufe durchzuiterieren und dann kannst du mit den Objekten machen, was du willst. Imo macht es nicht viel Sinn den << Operator für ein Konto zu überladen. Was soll den das ausgeben? Kontostand? Kontonummer? ..

std::list<Konto*> objList;
objList = meinKunde.getMeineKonten();

for (std::list<Konto*>::const_iterator it = objList.begin();
it != objList.end();
++it)
{
 std::cout << (*it)->getKontonummer() << std::endl;
}

Gegebenfalls kannst du da auch std::for_each benutzen. Das finde ich übersichtlicher, als das per copy zu lösen.

[jensa]

hallo,

besten dank für die hilfe funktioniert jetzt.

jedoch würde mich trotzdem die geschichte mit dem überladenen operator interessen.

[Tachyon]

jensa schrieb:

hallo,

besten dank für die hilfe funktioniert jetzt.

jedoch würde mich trotzdem die geschichte mit dem überladenen operator interessen.

Welche Lösung hast Du denn jetzt gewählt?

Ansonsten:

//in Konto
std::ostream& operator<<(std::ostream& ostr, const Konto& k)
{
   ostr << k.getKontonummer();
   //weitere Ausgaben, wenn benoetigt
}

//macht aus T* ein T&
template<typename T>
T& dereference(T* ptr){ return *ptr; }

//...

std::transform(objList.begin(), objList.end(), std::ostream_iterator<Konto>(std::cout), dereference<Konto>);

@drakon:
Imo macht es sehr wohl Sinn, den operator<< zu überladen, wenn man Ausgaben machen will. Die Streams sind in C++ das Mittel der Wahl für Ausgaben, und man ist mit überladenen Ausgabeoperatoren sehr viel flexibler, als wenn man jede Ausgabe von Hand strickt.