ich habe ein kleines Probelm mit ausgabe einer klasse.

das funktioniert:

void console(int& i)
{
    cout<<i<<endl;
    }

main()
...
list<int> test;
    for(int i=0; i<6; i++)test.push_front(i);
    for_each(test.begin(), test.end(), console); 
...

aber wenn ich jetzt meine adressklasse, die ich in list einfüge, am Bildschirm ausgeben will, funktioniert das nicht...

Adressliste mylist;
mylist.eingabe();
list<Adressliste> freunde;
freunde.push_front(mylist);
for_each(freunde.begin(), freunde.end(), console);

in der adressliste.h steht:

class Adressliste
{  string name, vorname, telefon;
      public:
            Adressliste(){}
            void eingabe();
            void ausgabe();
            void console(Adressliste& T);    
};

in der zugehörigen cpp:

void Adressliste::console(Adressliste& T)
{
    cout<<T.name<<T.vorname<<T.telefon<<endl;
    }

im zweiten code in for_each console steht, liegt mein problem... ich weiß das ich die Methode von adressliste nicht so aufrufen kann, aber wie kann ich die liste so übergeben damit ich die auch am bildschirm ausgeben werden kann?

Wenn ich zuvor ein Objekt von der Adressliste erstelle und dann z.B. "mylist.console()" schreibe, funktioniert das auch nicht.

Wäre super wenn mir einer helfen könnte mein problemchen zu lösen.

MfG
Gustl

ich habe ein kleines Probelm mit ausgabe einer klasse.

Grundsätzlich eine Frage vorneweg:
Ist dir der unterschied zwischen Funktionen, statischen Methoden (Methode = Funktion einer Klasse) und nicht-statischen Methoden bekannt?

Natürlich kann deine std::for_each nicht funktionieren wenn du weder den richtigen Namen angibst (console war deine freie Funktion, die Methode console ist über Adressliste::console zu erreichen, _aber_ da es sich um eine nicht-statische Methode handelt, würde es so auch nicht klappen [nicht-statische Methoden benötigen ein Objekt auf dem sie angewendet werden]).

Vielleicht solltest du dir mal den TR1 oder Boost, genauer...
- std::tr1::bind (Header <functional> sofern dein Compiler den TR1 beherrscht)
- boost::bind (Header <boost/bind.hpp> unter Verwendung der Boost-Bibliothek)
...ansehen

cu André

#include <iostream>
#include <list>
#include <algorithm>

class Address {
private:
	std::string lastname_, firstname_, phone_;
public:
	Address(){}
	std::string lastname() const { return lastname_; }
	void set_lastname(const std::string& lastname) { lastname_ = lastname; }
	std::string firstname() const { return firstname_; }
	void set_firstname(const std::string& firstname) { firstname_ = firstname; }
	std::string phone() const { return phone_; }
	void set_phone(const std::string& phone) { phone_ = phone; }
};
std::ostream& operator<<(std::ostream& os, const Address& address) {
	os << "Lastname:  " << address.lastname() << "\n"
	   << "Firstname: " << address.firstname() << "\n"
	   << "Phone:     " << address.phone() << std::endl;
	return os;
}
std::istream& operator>>(std::istream& is, Address& address) {
	std::string input;
	std::cout << "Please enter the lastname: ";
	is >> input;
	address.set_lastname(input);
	std::cout << "Please enter the firstname: ";
	is >> input;
	address.set_firstname(input);
	std::cout << "Please enter the phonenumber: ";
	is >> input;
	address.set_phone(input);
	return is;
}

void console(const Address& address) {
	std::cout << address << std::endl;
}

int main(int argc, char* argv[]) {
	Address a, b, c;
	std::list<Address> lst;
	std::cin >> a;
	lst.push_front(a);
	std::cin >> b;
	lst.push_front(b);
	std::cin >> c;
	lst.push_front(c);

	for_each(lst.begin(), lst.end(), &console);
	return 0;
}

Gut Schuß
VuuRWerK

[edit]Angepasst für Verwendung von for_each![/edit]

Ich habe es jetzt so gelöst:

Habe eine klasse adresse erstellt, eine klasse adressliste und habe die klasse adresse vererbt.

in der klasse adresse die ein und ausgabeoperatoren überladen und schon hat es funktioniert. So ähnlich wie VuuRWerK, nur habe ich die list in der klasse adressliste mit eingebaut

Das mit der console war von meiner seite wohl etwas schlecht geschildert.

Danke.
MfG Gustl

Die Klasse Adressliste ist eine Adresse

Ich weiß nicht ob das wirklich stimmt, dazu kenne ich deinen Code nicht, aber von der Logik her, ist es doch eigentlich nicht der Fall oder?;)

adressliste.h

#include "adresse.h"
#include <list>

class Adressliste:public Adresse
{     list<Adresse> liste;
      public:
             void eingabe();
             void ausgabe();
             void savetofile();
             void loadfromfile();

};

adresse.h

#include <string>
#include <iostream>

using namespace std;

class Adresse
{     protected:
      string name, vorname, telefonnr;
      public:
             Adresse(string n="", string v="", string t="");
             friend ostream& operator<<(ostream& o, Adresse& T);
             friend istream& operator>>(istream& i, Adresse& T);

};

Vielleicht macht es ja wirklich keinen großen sinn, aber ich denke so sollte ich es laut meiner aufgabenbeschreibung auch tun.

nur das loadfromfile bekomme ich noch nicht sauber hin.

Aber wie meinte der Lehrer dann das mit der vererbung..?... mhhh

Am besten ich frag ihn morgen mal.

So ähnlich wie VuuRWerK, nur habe ich die list in der klasse adressliste mit eingebaut

Sofern der du einen geeigneten Operator hast, kanst du auch in einen Rutsch einen Container auf diesen ausgeben:

std::vector<Address> v;
//...
std::copy(v.begin(), v.end(), ostream_iterator<Addresse>(cout, "\n"));
// Gibt alle Addressen getrennt mit "\n" aus...

cu André

Ich zeige euch jetzt mal den kompletten code, bitte nicht lachen, etwas anfängerstyle hat er.

main.cpp

#include <iostream>
#include "adressliste.h"
using namespace std;

int main()
{   Adressliste mylist;
    //mylist.loadfromfile();
    mylist.eingabe();
    mylist.eingabe();
    mylist.ausgabe();
    mylist.savetofile();
    system("PAUSE");
    return 0;
}

adresse.cpp

#include <string>
#include <iostream>
#include <iomanip>
#include "adresse.h"

using namespace std;

Adresse::Adresse(string n, string v, string t)
{  name= n;
   vorname= v;
   telefonnr= t;
}

ostream& operator<<(ostream& o, Adresse& T)
{   return o<<T.name<<" "<<T.vorname<<" "<<T.telefonnr<<endl;}

istream& operator>>(istream& i, Adresse& T)
{   cout<<"Name: ";i>>T.name;
    cout<<"Vorname: ";i>>T.vorname;
    cout<<"Telfonnummer: ";i>>T.telefonnr;
    return i;}

adresse.h

#include <string>
#include <iostream>
using namespace std;

class Adresse
{     protected:
      string name, vorname, telefonnr;
      public:
             Adresse(string n="", string v="", string t="");
             friend ostream& operator<<(ostream& o, Adresse& T);
             friend istream& operator>>(istream& i, Adresse& T);
};
#endif

adressliste.cpp

#include "adressliste.h"
#include <iostream>
#include <algorithm>
#include <fstream>
using namespace std;

fstream f;

void Adressliste::eingabe()
{  Adresse tmp;
   cin>>tmp;
   liste.push_back(tmp);
   }

void console(Adresse& T)
{  cout<<T;
   }

void Adressliste::ausgabe()
{  for_each(liste.begin(), liste.end(), console);
   }

void elementspeichern(Adresse &tmp)
{  f<<tmp;
   }

void Adressliste::savetofile()
{  f.open("datei.txt", ios::out);
   if(!f)cout<<"Fehler beim Oeffnen der Datei \"datei.txt\"!";
   else
   { for_each(liste.begin(), liste.end(), elementspeichern);
     f.close();
     }
   }

void Adressliste::loadfromfile()
{  Adresse tmp;
   f.open("datei.txt", ios::in);
   if(!f)cout<<"Fehler beim Oeffnen der Datei \"datei.txt\"!";
   else
   { f>>tmp;
     while(!f.eof())
     {  liste.push_back(tmp);
        f>>tmp;
        }
     f.close();
     }
}

adressliste.h

//---------------------------------------------------------------------------
#ifndef adresslisteH
#define adresslisteH
//---------------------------------------------------------------------------
#include "adresse.h"
#include <list>

class Adressliste:public Adresse
{     list<Adresse> liste;
      public:
             void eingabe();
             void ausgabe();
             void savetofile();
             void loadfromfile();
};
#endif

Genaue Fehlermeldung von Borland:

Project adressliste.exe raised exception class EStackOverflow with message 'Stack overflow'. Process stopped. Use Step or Run to continue.

Habe ich da irgendwo eine endlosschleife drin oder sowas?
Danke schonmal.

MfG Gustl

ich verstehs nicht...

Edit:
Wie kann ich herausfinden wo die Exception auftritt?
Wenn die Fehlermeldung kommt muss ich borland über den task manager schließen...

Übrigens solltest du die Strings als Const-Referenz statt als Kopie an die Funktionen übergeben. Und im Header kein using namespace verwenden, da dies den Namensraum für alle inkludierenden Dateien offenlegt und somit schnell zu Namenskonflikten führen kann.

Edit: Wenn du den Debugger benutzt, sollte das Programm bei einer Exception automatisch unterbrochen werden und zur Codestelle springen, bei der du dich gerade befindest. Ansonsten versuch es doch mal mit Konsolenausgaben.

Eben, wo tritt die Exception auf?

Leider weiß ich nicht was du damit meinst.. ich weiß nicht wo der fehler ist... borland blockiert dann.

Nexus schrieb:

Rekursion oder so hast du auch nicht im Spiel?

Nein, es ist keine Rekursion im Spiel. Das ist der gesamte code.

Nexus schrieb:

Übrigens solltest du die Strings als Const-Referenz statt als Kopie an die Funktionen übergeben.

Ok danke, werde ich anwenden. klingt auch logisch.

Nexus schrieb:

Und im Header kein using namespace verwenden, da dies den Namensraum für alle inkludierenden Dateien offenlegt und somit schnell zu Namenskonflikten führen kann.

Das habe ich schon oft zu hören bekommen, aber unser toller Lehrer macht das nicht... keine ahnung warum nicht... aber im moment spielt das jetzt keine rolle oder?

Nexus schrieb:

Edit: Wenn du den Debugger benutzt, sollte das Programm bei einer Exception automatisch unterbrochen werden und zur Codestelle springen, bei der du dich gerade befindest. Ansonsten versuch es doch mal mit Konsolenausgaben.

debugger richtig benutzen... leider auch noch nicht gelernt... hmpf...

ich probiers morgen mal mit const &string und mit einem anderen compiler.

Danke dir.

MfG Gustl

Das habe ich schon oft zu hören bekommen, aber unser toller Lehrer macht das nicht... keine ahnung warum nicht... aber im moment spielt das jetzt keine rolle oder?

Ja, Lehrer sind selten Vorbilder. Nein, für dein aktuelles Problem ist das irrelevant, aber es kann dich vor künftigen Problemen bewahren und dir gleich einen guten Stil angewöhnen.

Gustl schrieb:

debugger richtig benutzen... leider auch noch nicht gelernt... hmpf...

Der Debugger ist wirklich sehr praktisch. Aber wie gesagt, für den Anfang reichen auch Konsolenausgaben, so kannst du den Fehler schon gut einschränken:

int main()
{
    std::cout << "Anfang von main()" << std::endl;
    // ...
    std::cout << "Vor dem Foo()-Aufruf" << std::endl;
    Foo();
    std::cout << "Nach dem Foo()-Aufruf" << std::endl;
    // ...
    std::cout << "Ende von main()" << std::endl;
}

dynamisch werde ich es morgen probieren,danke.
Aber eigentlich sollte es doch bei 2 "Adressen" in der Liste funktionieren...

Mir sind schon einige Dinge aufgefallen, u.a. würde ich globale Variablen vermeiden

Anbei mal eine weitere Variante, dir wird dir und deinen Lehrer wohl an einigen missfallen, aber nur damit du mal etwas anderes gesehen hast

// main.cpp
#include <iostream>
#include <fstream>
#include <list>
#include <algorithm>
#include "adresse.h"

// Ich habe die Adresseingabe (Behandlung von deiner UI [Console]) mal von der
// eigentlichen Programmlogik getrennt. Siehe auch Anmerkung in der adresse.cpp

// Einzelne Adresse eingeben
Adresse AdresseEingeben()
{
    std::string name;
    std::cout << "Name: ";
    std::cin >> name;

    std::string vorname;
    std::cout << "Vorname: ";
    std::cin >> vorname;

    std::string telefonnr;
    std::cout <<"Telefonnummer: ";
    std::cin >> telefonnr;

    return Adresse(name, vorname, telefonnr);
}

// Adressen aus Datei einlesen
std::list<Adresse> AdressenEinlesen(
    std::string const & dateiname)
{
    std::list<Adresse> adressen;

	// 1. Datei Öffnen
	std::fstream datei(dateiname.c_str(), std::ios::in);
	if(datei.bad())
		return adressen;

	// 2. Daten übertragen
	std::copy(
		std::istream_iterator<Adresse>(datei),  // Vom Dateibegin...
		std::istream_iterator<Adresse>(),       // ...bis kein Eintrag mehr existiert
		std::back_insert_iterator<std::list<Adresse> >(adressen)); // an die Liste hängen

	return adressen;
}

// Adressen in Datei speichern
bool AdressenSpeichern(
    std::string const & dateiname,
	std::list<Adresse> const & adressen)
{
	// 1. Datei zum Schreiben öffnen
	std::fstream datei(dateiname.c_str(), std::ios::out);
	if(datei.bad()) {
		std::cout << "Fehler beim Oeffnen der Datei \"" << dateiname << "\"!";
		return false;
	}

	// 2. Daten in die Datei schreiben
	std::copy(
		adressen.begin(),  // Vom Listenbegin...
		adressen.end(),    // ...bis Listenende
		std::ostream_iterator<Adresse>(datei)); // an die Datei hängen

	return true;
}

int main()
{
	std::list<Adresse> adressen = AdressenEinlesen("datei.txt");
    adressen.push_back(AdresseEingeben());
    adressen.push_back(AdresseEingeben());
    adressen.push_back(AdresseEingeben());

    // Ausgabe auf der Console
	// Und zwar wird jedes Element der Liste an den entsprechenden Ausgabestream
	// übergeben, mit den dahinter angegebenen Trennzeichen
    std::copy(adressen.begin(), adressen.end(),
		std::ostream_iterator<Adresse>(std::cout, "\n"));

	// Ausgabe in einer Datei
	if(!AdressenSpeichern("datei.txt", adressen));

	system("PAUSE"); // Würde ich mit Vorsicht verwenden
    return 0; // Unnötig, wird bei in der main-Funktion implizit gemacht
}

// Adresse.h
#ifndef ADRESSE_HEADER
#define ADRESSE_HEADER

#include <string>
#include <iostream>

// using namespace std;
// Bitte kein "using namespace" im Header, ansonsten brauch man garkeine
// Namensräume. using namespace im Header macht einen Namensraum global
// sichtbar, was nicht Sinn von Namensräumen ist.

class Adresse
{
    private: // Mach niemals etwas protected, wenn du dir nicht der Konsequenzen
             // bewusst bist.
        std::string name;       // Ich würde Variablen niemals in eine Reihe quetschen,
        std::string vorname;    // Anfänger machen dann gerne Fehler. Ich sag nur
        std::string telefonnr;  // int* a, b; => a=int-Zeiger, b=int

    public:
        Adresse(
            std::string const & name = "",      // Gerade im Header würde ich von
            std::string const & vorname ="",    // Abkürzungen die Finger lassen, der
            std::string const & telefonnr =""); // Header dient auch zur Übersicht.

        friend std::ostream & operator<<(
            std::ostream & stream,
            Adresse const & adresse);
		friend std::istream & operator>>(
            std::istream & stream,
            Adresse & adresse);

        std::string GetName() const;
        std::string GetVorname() const;
        std::string GetTelefonNr() const;
        void SetName(
            std::string const & name);
        void SetVorname(
            std::string const & vorname);
        void SetTelefonnr(
            std::string const & telefonnr);
};

#endif

// Adresse.cpp
#include "adresse.h"

using namespace std;

Adresse::Adresse(
    string const & name,      // 1. Hasse ich grundsätzlich Abkürzungen im Code
    string const & vorname,   // 2. Sollten Objekte in der Regel per const & 
    string const & telefonnr) //    übergeben werden, wenn keine Änderung/Kopie nötig
:   name(name),               // 3. Initialisierung ist der nachträglichen Zuweisung
    vorname(vorname),         //    vorzuziehen. Dazu dient die Initialisierungsliste
    telefonnr(telefonnr)      //    des Konstruktors
{
}

ostream& operator<<(
    ostream & stream,
    Adresse const & adresse) // Die Adresse wird nicht Manipuliert => const &
{
    stream << adresse.name << " "
           << adresse.vorname <<" "
           << adresse.telefonnr;
    return stream;
}

istream& operator>>(
    istream & stream,
    Adresse & adresse)
{
    // cout hat hier nichts zu suchen, dies ist ein Eingabestream, das kann
    // auch eine Datei sein. Dort macht eine Ausgabe keinen Sinn. Dann lieber
    // in dem Fall eine separate Funktion. Und diese möglichst nicht in der
    // Adresse (Logische Trennung von Programmlogik und UI für bessere Wartbarkeit).
    // Zudem bitte nicht mehrere Befehle in eine Zeile quetschen.
    stream >> adresse.name;
    stream >> adresse.vorname;
    stream >> adresse.telefonnr;
    return stream;
}

std::string Adresse::GetName() const
{
    return name;
}

std::string Adresse::GetVorname() const
{
    return vorname;
}

std::string Adresse::GetTelefonNr() const
{
    return telefonnr;
}

void Adresse::SetName(
    std::string const & name)
{
    this->name = name;
}

void Adresse::SetVorname(
    std::string const & vorname)
{
    this->vorname = vorname;
}

void Adresse::SetTelefonnr(
    std::string const & telefonnr)
{
    this->telefonnr = telefonnr;
}

Jetzt habe ich ein anderes Problem...
Der Borland Builder bringt mir eine stack overflow fehlermeldung bei öfterem starten des programms.

Ich zeige euch jetzt mal den kompletten code, bitte nicht lachen, etwas anfängerstyle hat er.

main.cpp

#include <iostream>
#include "adressliste.h"
using namespace std;

int main()
{   Adressliste mylist;
    //mylist.loadfromfile(); //dateinamen angeben!?
    mylist.eingabe(); //für sowas hast du doch extra operatoren überladen (>> und <<)
    mylist.eingabe(); //   ---- " -----
    mylist.ausgabe(); //   ---- " -----
    mylist.savetofile(); //dateinamen angeben?!
    system("PAUSE"); //schlechte variante die konsole offen zu lassen... siehe dazu auch Consolen-FAQ
    return 0; //unnötig
}

adresse.cpp

#include <string> //solltest du im header schon haben
#include <iostream> // ----- " ----
#include <iomanip> //verwendest du nie
#include "adresse.h"

using namespace std;

Adresse::Adresse(string n, string v, string t) //größere datentypen übergibt man in der Regel nicht per Value(Kopie) sondern per const Referenz (const string &n)
//initialisierungsliste nutzen! :
 : name (n), vorname (v), telefonnr (t)
{/*  name= n;
   vorname= v;
   telefonnr= t;
ist damit unnötig*/
}

#if 0 //zum ausklammern des codes hab ich hier mal den Präprozessor genutzt - wollte es nicht ganz löschen
ostream& operator<<(ostream& o, Adresse& T) //T ist zwar nicht gerade nen toller name dafür, aber das eigtl Problem ist, dass du hier eine Referenz nimmst und keine const Referenz - somit kann man kein const Objekt ausgeben
#endif
ostream& operator << (ostream &o, const Adresse &T)
{   return o<<T.name<<" "<<T.vorname<<" "<<T.telefonnr<<endl;}

istream& operator>>(istream& i, Adresse& T)
{//üblicherweise sind Ein- und Ausgabe unabhängig von cout / cin zu implementieren! also:
    /*cout<<"Name: ";*/ i >> T.name; 
    /*cout<<"Vorname: ";*/ i>>T.vorname;
    /*cout<<"Telfonnummer: ";*/ i>>T.telefonnr;
    return i;
}

adresse.h

#include <string>
#include <iostream>
//using namespace std;
/*wurde glaube ich schon erwähnt, dass man das nicht tut...*/

#ifndef ADRESSE_H_INCLUDED
#define ADRESSE_H_INCLUDED
//das hattest du vergessen, das #endif hattest du aber - hab mir die fehlermeldung zwar net durchgelesen, aber das wird sie gewesen sein ^^

class Adresse
{     protected: //ich würde private nehmen
      string name, vorname, telefonnr;
      public:
             Adresse(const std::string &n="", const std::string &v="", const std::string &t=""); //übergaben per const referenz und namensraum mit angebgen
             friend std::ostream& operator<<(std::ostream& o, const Adresse& T); //namensraum + ref als const gemarkt
             friend std::istream& operator>>(std::istream& i, Adresse& T);
/*Getter + Setter fehlen, z.Bsp.:*/
             const std::string& GetName() const //die funktion ändert das objekt nicht, deshalb das const nach der Parameterliste (die in dem Fall leer ist)
                 { return name; }
             void SetName(const std::string &_name)
                 { name = _name; }
}; //namensraum
#endif //#ifndef ADRESSE_H_INCLUDED

adressliste.cpp

#include "adressliste.h"
#include <iostream>
#include <algorithm>
#include <fstream>
using namespace std;

fstream f; //schlechte angewohnheit, globale Variable zu nutzen - und eigtl auch immer vermeidbar

#if 0 /* für so etwas gibt es operatoren >> und << - und dann machst du eben nur ne Funktion Add(const Adresse &value)*/
void Adressliste::eingabe()
{
   Adresse tmp;
   cin>>tmp;
   liste.push_back(tmp);
}

void console(Adresse& T)
{
  cout<<T;
}

void Adressliste::ausgabe()
{
  for_each(liste.begin(), liste.end(), console);
}

void elementspeichern(Adresse &tmp)
{  f<<tmp;
   }

void Adressliste::savetofile()
{  f.open("datei.txt", ios::out);
   if(!f)cout<<"Fehler beim Oeffnen der Datei \"datei.txt\"!";
   else
   { for_each(liste.begin(), liste.end(), elementspeichern);
     f.close();
     }
   }

void Adressliste::loadfromfile()
{  Adresse tmp;
   f.open("datei.txt", ios::in);
   if(!f)cout<<"Fehler beim Oeffnen der Datei \"datei.txt\"!";
   else
   { f>>tmp;
     while(!f.eof())
     {  liste.push_back(tmp);
        f>>tmp;
        }
     f.close();
     }
}
#endif

adressliste.h

//---------------------------------------------------------------------------
#ifndef adresslisteH
#define adresslisteH
//---------------------------------------------------------------------------
#include "adresse.h"
#include <list>

class Adressliste:public Adresse //die vererbung ist hier nicht richtig - Adressliste ist keine Adresse sondern beinhaltet nur Adressen -> nur nen Container mit Adresse als template-Parameter als Member, hast du ja aber schon (std::list <Adresse> liste)
{
      private: //ist es zwar per default, aber ich würds trotzdem mit hinschreiben
             list<Adresse> liste;
      public:
             void eingabe();
             void ausgabe();
             void savetofile();
             void loadfromfile();
};
#endif

Hoffe, du siehst noch bissl durch und nimmst dir die Zeit, das alles mal durchzulesen und deine Verbesserung hier zu posten - nat. darfst du auch fragen, falls du etwas (noch) nicht verstehst...

bb

Aa ich heute Arbeiten muss und Abends in die Schule geh, werde ich nicht viel Zeit haben den code zu überarbeiten. Werde mich morgen drauf stürzen und poste meine abgewandelte version vom code hier ins Forum, aber die 2 Klassen würde ich schon gerne beibehalten, da dies genau in der Aufgabenstellung so drin steht.

Ich habe mir eure posts genau durchgelsen und hab festgestellt das ich ganz sicher hier noch Verständnisprobleme haben werde:

// 1. Datei Öffnen 
    std::fstream datei(dateiname.c_str(), std::ios::in); 
    if(datei.bad()) 
        return adressen; 

    // 2. Daten übertragen 
    std::copy( 
        std::istream_iterator<Adresse>(datei),  // Vom Dateibegin... 
        std::istream_iterator<Adresse>(),       // ...bis kein Eintrag mehr existiert 
        std::back_insert_iterator<std::list<Adresse> >(adressen)); // an die Liste hängen

dateiname.c_str(),

Keine ahnung was diese c_str() bringt...

datei.bad())

ebenso

std::copy( 
        std::istream_iterator<Adresse>(datei),  // Vom Dateibegin... 
        std::istream_iterator<Adresse>(),       // ...bis kein Eintrag mehr existiert 
        std::back_insert_iterator<std::list<Adresse> >(adressen)); // an die Liste hängen

das mus sich wohl einfach mal probieren, aber was der iterator da soll ist mir auch unverständlich, haben doch gar keinen bestimmt...?

der rest ist mir verständlich, zumindest kann ich mir es denken.
Danke euch

MfG Gustl

...aber die 2 Klassen würde ich schon gerne beibehalten, da dies genau in der Aufgabenstellung so drin steht.

Dann gehe ich mal davon aus das du die Adressliste selbst (sprich ohne std::list oder vergleichbares) implementieren sollst.

Gustl schrieb:

Ich habe mir eure posts genau durchgelsen und hab festgestellt das ich ganz sicher hier noch Verständnisprobleme haben werde:

// 1. Datei Öffnen 
    std::fstream datei(dateiname.c_str(), std::ios::in); 
    if(datei.bad()) 
        return adressen;

dateiname.c_str(),

Keine ahnung was diese c_str() bringt...

datei.bad())

ebenso

std::fstream erwartet als ersten Parameter einen C-String, std::string gibt über die Funktion .c_str() eben einen solchen (konstanten) zurück. Und was die Funktion bad() von fstream angeht, sollte dein Englisch ausreichen um dies zu verstehen.

Im nächsten C++ Standard wird fstream auch std::string als direkten Parameter zulassen.

Gustl schrieb:

std::copy( 
        std::istream_iterator<Adresse>(datei),  // Vom Dateibegin... 
        std::istream_iterator<Adresse>(),       // ...bis kein Eintrag mehr existiert 
        std::back_insert_iterator<std::list<Adresse> >(adressen)); // an die Liste hängen

das mus sich wohl einfach mal probieren, aber was der iterator da soll ist mir auch unverständlich, haben doch gar keinen bestimmt...?

Auch Datenströme haben Iteratoren. Das Konzept der Iteratoren zieht sich durch das gesamte C++, was auch Sinn macht um viele Ähnliche Abläufe zu vereinheitlichen.

Und hier spielt dein "operator>>(istream&, Adresse&" eine wesentliche Hauptrolle. Der std::back_insert_iterator Iteriert über das Listenende mittels "push_back"...

cu André

Ich habe das ganze Projekt nochmal von neuem begonnen (bzw. wollte), mit Hilfe eurer Hifestellungen.
Aber beim Versuche das Ding zu starten bringt er mir wieder den stack_overflow Fehler...

Gut, ich habe jetzt euer std:: nicht befolgt, aber daran kann es doch wirklich nicht liegen oder?

main.cpp

#include <string>
#include <iostream>
#include "adresse.h"

using namespace std;

int main()
{   Adresse Test("Rolf","Mueller","Hintere Pfaffenleite","8","08991-666");
    cout<<Test;
    //Test.loadfromfile();
    //Test.eingabe();
    //Test.eingabe();
    //Test.ausgabe();
    //Test.savetofile();
    getchar();
    return 0;
}

adresse.h

//---------------------------------------------------------------------------
#ifndef adresseH
#define adresseH
#include <string>
#include <iostream>

using namespace std;

class Adresse
{   string name;
    string vorname;
    string street;
    string hausnr;
    string phone;
    public:
       Adresse(
          string const & name="",
          string const & vorname="",
          string const & street="",
          string const & hausnr="",
          string const & phone="")
:         name(name),
          vorname(vorname),
          street(street),
          hausnr(hausnr),
          phone(phone)
          {}

       friend ostream& operator<<(ostream& outstream, Adresse & const adresse);
};
//---------------------------------------------------------------------------
#endif

adresse.cpp

//---------------------------------------------------------------------------
#include "adresse.h"
#include <string>
#include <iostream>

using namespace std;

ostream& operator<<(ostream& outstream, Adresse & const adresse)
{   outstream << adresse.name << " "
              << adresse.vorname << " "
              << adresse.street << " "
              << adresse.hausnr << " "
              << adresse.phone;
    return outstream;
}

//---------------------------------------------------------------------------

Das ist der komplette code...

Bei der .h bringt er mir bei

string const & name="",

ein Warning:
"Cannot create pre-compieled header: initialized data in header"

Benutze Borland Enterprise Suite Version 6.0 von 2002

Woran kanns denn liegen?
MfG Gustl

EDIT: Habe es jetzt auf einen anderen Rechner versucht zu starten, dort konnte ich es ohne Probleme 3-4x aufrufen, dann war wieder schluß(stack overflow) und ich musste den borland wieder über den taskmanager beenden.

Ansonsten sehe ich vom Code her abgesehen von den falsch verwendeten consts nichts.

Die Fehlermeldung sagt dir wahrscheinlich ja, was das Problem bei dir ist. Nimm die Defaultinitialisierung mal raus. Dann sollte es auch funktionieren.

Am std:: liegts sicher nicht. (Es sei denn du hättest ein sehr merkwürdiges und irgendwie reinpassendes Konstrukt, dass dir einen Laufzeitfehler verursacht was bei dir nicht der Fall ist).

Aber eine weiter Sache die ich nicht verstehe ist folgendes,

ich habe zwei Klassen (adresse.h & adressliste.h)
in der adressliste habe ich #include "adresse.h" damit ich bei den Eigenschaften list<Adresse> Liste; sagen kann.
In der cpp von adressliste kann ich ja dann ohne include "adresse.h" ein objekt von adresse erzeugen.. ist das normal?