for_each ausgabe einer klasse

[Gustl]

Meine Klassen schauen jetzt so aus:

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.

[Firefighter]

Also eine Adressliste ist definitiv keine Adresse...sondern eine Liste von Adressen, ich denke da Reicht es einfach wenn du der Adressliste ein Attribut vom Typ list<Adresse> gibst(wie schon passiert). Und das Vererben einfach weglässt.

[Gustl]

Jetzt wo dus mir sagst, seh ich es auch. stimmt, würde reichen.

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

[Firefighter]

Also in deiner aufgabenstellung habe ich nichts von Vererbung gelesen?:D

[Gustl]

Am besten ich frag ihn morgen mal.

[asc]

Gustl schrieb:

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é

[Gustl]

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();
    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

[Nexus]

Wo tritt die Exception auf? Kann es sein, dass du so viele Einträge hast, dass der Stack nicht mehr ausreicht? In dem Falle kannst du die Adressliste mit new dynamisch anlegen und mit delete wieder löschen.

[Gustl]

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

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

[Nexus]

Eben, wo tritt die Exception auf? Rekursion oder so hast du auch nicht im Spiel?

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

[Gustl]

Nexus schrieb:

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

[Nexus]

Gustl schrieb:

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

[asc]

Gustl schrieb:

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

[unskilled]

Gustl schrieb:

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

[Gustl]

Ihr macht euch echt sehr viel mühe mir zu helfen, das finde ich einfach klasse und spreche hiermit ein großes lob aus.

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

[asc]

Gustl schrieb:

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

[Gustl]

So Leute, jetzt bin ich schon sehr verwundert.

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.

[drakon]

Hmm. Das Ding ist recht alt. Hast du es schon mal mit etwas aktuellerem versucht? (VC, oder GCC z.B)

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

[Gustl]

Habe es jetzt mit visual studio 2005 probiert, und siehe da, kein stack overflow mehr.

[Nexus]

Wenn du in Zukunft Funktionen oder Klassen aus der Standardbibliothek nicht kennst, kannst du sie in einer C++-Referenz deiner Wahl nachschlagen. Ich empfehle www.cplusplus.com.