Du musst halt deiner Tier Klasse und den davon abgeleiteten Klassen Funktionen zum Schreiben in eine Textdatei spendieren (virtual) und die dann aufrufen.

(Ausgabe funktioniert)

was meinst Du damit genau?
Wenn die Ausgabe aller Tiere auf der Konsole (std::cout) funktioniert, so funktioniert sie genauso in ein Textfile.
Statt:

for( ..alle Tiere.. )
        cout << *tier ...;

schreibst Du

ofstream file("textfile.txt");
    for( ..alle Tiere.. )
        file << *tier ..; // genau wie oben

ofstream file ist ein std::ostream , genau wie std::cout ein std::ostream ist. Ist die Antwort, die Du wolltest?

Gruß
Werner

Statt:

for( ..alle Tiere.. )
        cout << *tier ...;

schreibst Du

ofstream file("textfile.txt");
    for( ..alle Tiere.. )
        file << *tier ..; // genau wie oben

ofstream file ist ein std::ostream , genau wie std::cout ein std::ostream ist. Ist die Antwort, die Du wolltest?

Ich glaube, dass ist das was ich will.

Kann das so irgendwie funktionieren?

vector<tier*> x;
      //dann speicher ich da ein paar Tiere rein
      ofstream file("output.txt");
      for (size_t i=0; i<x.size(); ++i)
    {
        file << x[i];
    }

wobei ich das schon habe:

ostream& operator<<(ostream& s, const tier& rhs)
{
    rhs.PrettyPrint(s);
    return s;
}

und

void tier::PrettyPrint(ostream& s) const
{
    s << "Name des Tieres: "<< name <<endl;
    s << "Geburtsdatum: "<< geb <<endl;
    s << "Gewicht des Tieres: "<<kg<<" kg"<<endl;
  // usw...
}

manchmal hängt sich alles auf wenn ich

vector<tier*> x;
    x.push_back(&a);
    x.push_back(&b);
    x.push_back(&c);
    x.push_back(&d);
    x.push_back(&e);
    x.push_back(new pute("Josef", datum(13,6,1999),37.2,7.2)); //das hier verwende

    Ausgabe(x);

    cout<<"Anzahl der Kuehe: "<<kuh::cow<<endl;

    cout<<"\nAeltestes Tier: "<<endl;
    auto it=min_element(x.begin(),x.end(),Geb_aelter);
    cout<<endl<<**it<<endl;

    cout<<"Wertvollstes Tier: "<<endl;
    it=min_element(x.begin(),x.end(),wertvoller);
    cout<<endl<<**it;
    cout<<".........wird verkauft\n"<<endl;

    delete *it;
    x.erase(it);

wenn ich es auskommentiere, dann funktioniert soweit wieder alles. Aber es kann sein, dass sich wieder alles aufhängt bei delete *it; dann mach ich oben den Kommentar weg und es funktioniert wieder. An was kann das liegen?

An was kann das liegen?

An ganz vielen Dingen. Zeig mal ein vollständiges Programm, an dem man den Fehler nachvollziehen kann. Siehe auch dritter Link in meiner Signatur.

// main.cpp
#include "schaf.h"
#include "huhn.h"
#include <vector>
#include <algorithm>
#include <numeric>
#include <fstream>

void Ausgabe(const vector<tier*>& v)
{
  for (size_t i=0; i<v.size(); ++i)
    {
        v[i]->PrettyPrint(cout);
    }
}

bool Geb_aelter(const tier* a, const tier* b)
{
    return a->Getdatum()<  b->Getdatum();
}
bool wertvoller(const tier* a, const tier* b)
{
    return a->wert()>b->wert();
}

float WERT(float result, tier* a)
{
    return result+a->wert();
}
int main()
{
    kuh a("Resi", datum(21,1,2006), 600, 30, 5, 0.9);
    //a.PrettyPrint(cout);

    kuh b("Heidi", datum(21,1,2006), 735, 30, 5, 0.9);
    //b.PrettyPrint(cout);

    pute c("Putput", datum(19,1,2005), 20, 6);
    //c.PrettyPrint(cout);

    huhn d("Pipipi", datum(5,5,2009), 7, 5.6, 30, 0.1);
    //d.PrettyPrint(cout);

    schaf e("Meeeeh", datum(24,12,2009), 90, 15, 4.5, 1.6, 1, 2);
    //e.PrettyPrint(cout);
    //cout<<"Viecher insgesamt: "<<tier::n<<endl;
    //cout<<"Gesamte Beinanzahl: "<<vierbeiner::baz4+zweibeiner::baz2<<endl<<endl;

    vector<tier*> x;
    x.push_back(&a);
    x.push_back(&b);
    x.push_back(&c);
    x.push_back(&d);
    x.push_back(&e);
    x.push_back(new pute("Josef", datum(13,6,1999),37.2,7.2));
    //x.back()->PrettyPrint(cout);
    //cout<<endl<< *x.back()<<endl;

    Ausgabe(x);

    cout<<"Anzahl der Kuehe: "<<kuh::cow<<endl;

    cout<<"\nAeltestes Tier: "<<endl;
    auto it=min_element(x.begin(),x.end(),Geb_aelter);
    cout<<endl<<**it<<endl;

    cout<<"Wertvollstes Tier: "<<endl;
    it=min_element(x.begin(),x.end(),wertvoller);
    cout<<endl<<**it;
    cout<<".........wird verkauft\n"<<endl;

    delete *it;
    x.erase(it);

    cout<<"Gesamtwert der Tiere: "<<accumulate(x.begin(),x.end(),0.0,WERT)<<" Euro"<<endl;
    cout<<"Gesamte Beinanzahl: "<<vierbeiner::baz4+zweibeiner::baz2<<endl;

    ofstream file("output.txt");
      for (size_t i=0; i<x.size(); ++i)
    {
        file << *x[i];
    }
    return 0;
}

//datum.h
#ifndef DATUM_H
#define DATUM_H
#include <iostream>

using namespace std;

class datum
{
    public:
        /** Default constructor */
        datum();
        datum(int tag, int monat, int jahr);
        /** Default destructor */
        virtual ~datum();
        /** Access t
         * \return The current value of t
         */
        virtual int Gett() const { return t; }
        /** Set t
         * \param val New value to set
         */
        virtual void Sett(int val) { t = val; }
        /** Access m
         * \return The current value of m
         */
        virtual int Getm()  const { return m; }
        /** Set m
         * \param val New value to set
         */
        virtual void Setm(int val) { m = val; }
        /** Access j
         * \return The current value of j
         */
        virtual int Getj()  const { return j; }
        /** Set j
         * \param val New value to set
         */
        virtual void Setj(unsigned int val) { j = val; }

        bool operator<(const datum& rhs) const{return (j<rhs.j||(j==rhs.j&&m<rhs.m)||(j==rhs.j&&m==rhs.m&&t<rhs.t));};
        bool operator> (const datum& rhs) const{return (j>rhs.j||(j==rhs.j&&m>rhs.m)||(j==rhs.j&&m==rhs.m&&t>rhs.t));};
        bool operator== (const datum& rhs) const{return (j==rhs.j&&m==rhs.m&&t==rhs.t);};
    protected:
    private:
        int t; //!< Member variable "t"
        int m; //!< Member variable "m"
        int j; //!< Member variable "j"
};
ostream& operator<<(ostream& s, const datum& rhs);
#endif // DATUM_H

//datum.cpp
#include "datum.h"

datum::datum()
: t(0), m(0), j(0)
{

}
datum::datum(int tag, int monat, int jahr)
: t(tag), m(monat), j(jahr)
{
    if(t<1)
    t=1;
    if(m<1)
    m=1;
    if(t>28&&m==2)
    t=28;
    if(t>30&&(m==4||m==6||m==9||m==11))
    t=30;
    if(t>31&&(m==1||m==3||m==5||m==7||m==8||m==10||m>=12))
    t=31;
    if(m>12)
    m=12;
    if(j>2012)
    j=2012;

}

datum::~datum()
{
    //dtor
}

ostream& operator<<(ostream& s, const datum& rhs)
{
    s <<  rhs.Gett()<< "."<<rhs.Getm()<<"."<<rhs.Getj();
    return s;
}

//tier.h
#ifndef TIER_H
#define TIER_H

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

using namespace std;

class tier
{
    public:

        static int n;
        /** Default constructor */
        tier(const string Name, const datum& Geburtsdatum, float Gewicht);
        /** Default destructor */
        virtual ~tier();
        /** Copy constructor
         *  \param other Object to copy from
         */
        tier(const tier& other);
        /** Access name
         * \return The current value of name
         */
        const string Getname() const { return name; }
        /** Access geb
         * \return The current value of geb
         */
        const datum Getgeb() const { return geb; }
        /** Access kg
         * \return The current value of kg
         */
        float Getkg() const { return kg; }
        /** Set kg
         * \param val New value to set
         */
        void Setkg(float val) { kg = val; }

        datum Getdatum()  const { return geb; }

        virtual float wert() const {return 0.0f;}

        virtual void PrettyPrint(ostream& s) const;

    protected:
    private:
        const string name; //!< Member variable "name"
        const datum geb; //!< Member variable "geb"
        float kg; //!< Member variable "kg"
};
ostream& operator<<(ostream& s, const tier& rhs);

#endif // TIER_H

//tier.cpp
#include "tier.h"

int tier::n=0;

tier::tier(const string Name, const datum& Geburtsdatum, float Gewicht)
: name(Name), geb(Geburtsdatum), kg(Gewicht)
{
    n++;
    //ctor
}

tier::~tier()
{
    n--;
    //dtor
}

tier::tier(const tier& other)
{
    //copy ctor
}

ostream& operator<<(ostream& s, const tier& rhs)
{
    rhs.PrettyPrint(s);
    return s;
}

void tier::PrettyPrint(ostream& s) const
{
    s << "Name des Tieres: "<< name <<endl;
    s << "Geburtsdatum: "<< geb <<endl;
    s << "Gewicht des Tieres: "<<kg<<" kg"<<endl;
}

//vierbeiner.h
#ifndef VIERBEINER_H
#define VIERBEINER_H

#include "tier.h"

class vierbeiner : public tier
{
    public:
    static int baz4;
        /** Default constructor */
        vierbeiner(const string Name, const datum Geburtsdatum, float Gewicht);
        /** Default destructor */
        virtual ~vierbeiner();
        int Getbaz4() const { return baz4; }
    protected:
    private:

};

#endif // VIERBEINER_H

//vierbeiner.cpp
#include "vierbeiner.h"

int vierbeiner::baz4(0);

vierbeiner::vierbeiner(const string Name, const datum Geburtsdatum, float Gewicht)
: tier(Name, Geburtsdatum, Gewicht)
{
   baz4+=4;
}

vierbeiner::~vierbeiner()
{
    baz4-=4;
}

//zweibeiner.h
#ifndef ZWEIBEINER_H
#define ZWEIBEINER_H

#include "tier.h"

class zweibeiner : public tier
{
    public:
    static int baz2;
        /** Default constructor */
        zweibeiner(const string Name, const datum& Geburtsdatum, float Gewicht);
        /** Default destructor */
        virtual ~zweibeiner();
        /** Access baz
         * \return The current value of baz
         */
        int Getbaz2() const { return baz2; }
    protected:
    private:
};

#endif // ZWEIBEINER_H

//zweibeiner.cpp
#include "zweibeiner.h"

int zweibeiner::baz2(0);
zweibeiner::zweibeiner(const string Name, const datum& Geburtsdatum, float Gewicht)
: tier(Name, Geburtsdatum, Gewicht)
{
    baz2+=2;
    //ctor
}

zweibeiner::~zweibeiner()
{
    baz2-=2;
    //dtor
}

//kuh.h
#ifndef KUH_H
#define KUH_H

#include "vierbeiner.h"

class kuh : public vierbeiner
{
    public:
        static int cow;
        /** Default constructor */
        kuh(const string Name, const datum Geburtsdatum, float Gewicht, float Milchleistung, float Fleischpreis, float Milchpreis);
        /** Default destructor */
        virtual ~kuh();

        float Getliter() const { return liter; }
        void Setliter(int val) { liter = val; }
        float Getfleischpreis() const {return fleischpreis;}
        void Setfleischpreis(int val) { fleischpreis = val; }
        float Getmilchpreis() const { return milchpreis; }
        void Setmilchpreis(int val) { milchpreis = val; }

        void PrettyPrint(ostream& s) const;

        float wert() const { return liter*milchpreis+fleischpreis*tier::Getkg();}
    protected:
    private:
        float liter; //!< Member variable "liter"
        float fleischpreis;
        float milchpreis;
};
ostream& operator<<(ostream& s, const kuh& rhs);

#endif // KUH_H

//kuh.cpp
#include "kuh.h"
int kuh::cow(0);

kuh::kuh(const string Name, const datum Geburtsdatum, float Gewicht, float Milchleistung, float Fleischpreis, float Milchpreis)
:vierbeiner(Name, Geburtsdatum, Gewicht), liter(Milchleistung), fleischpreis(Fleischpreis), milchpreis(Milchpreis)
{
    cow++;

    //ctor
}

kuh::~kuh()
{
    cow--;
    //dtor
}

void kuh::PrettyPrint(ostream& s) const
{
    s<< "Kuh: "<<endl;
    tier::PrettyPrint(s);
    s << "Milchleistung/Monat: "<< liter<<" Liter"<<endl;
    s << "Fleischpreis: " << kuh::Getfleischpreis()<<" Euro"<<endl;
    s<< "Milchpreis: " << kuh::Getmilchpreis()<<" Euro"<<endl;
    s<< "Aktueller Wert: "<<wert()<<" Euro"<<endl;
    s<< "Beinanzahl: "<<vierbeiner::baz4%4+4<<endl<<endl;
}

ostream& operator<<(ostream& s, const kuh& rhs)
{
    rhs.PrettyPrint(s);
    return s;
}

//schaf.h
#ifndef SCHAF_H
#define SCHAF_H

#include "kuh.h"

class schaf : public kuh
{
    public:
        static int sheep;
        /** Default constructor */
        schaf(const string Name, const datum Geburtsdatum, float Gewicht, float Milchleistung, float Fleischpreis, float Milchpreis, float Wolle, float Wollpreis);
        /** Default destructor */
        virtual ~schaf();
        float Getwolle() const { return wolle; }
        void Setwolle(float val) { wolle = val; }
        float Getwollpreis() const { return wollpreis; }
        void Setwollpreis(float val) { wollpreis = val; }
        void PrettyPrint(ostream& s) const;
        float wert() const {return kuh::wert()+wolle*wollpreis;}
    protected:
    private:
    float wolle;
    float wollpreis;
};

ostream& operator<<(ostream& s, const schaf& rhs);

#endif // SCHAF_H

//schaf.cpp
#include "schaf.h"
int schaf::sheep(0);
schaf::schaf(const string Name, const datum Geburtsdatum, float Gewicht, float Milchleistung, float Fleischpreis, float Milchpreis, float Wolle, float Wollpreis)
: kuh(Name, Geburtsdatum, Gewicht, Milchleistung, Fleischpreis, Milchpreis), wolle(Wolle), wollpreis(Wollpreis)
{
    kuh::cow--;
    sheep++;
    //ctor
}

schaf::~schaf()
{
    kuh::cow++;
    sheep--;
    //dtor
}

void schaf::PrettyPrint(ostream& s) const
{
    s<<"Schaf: "<<endl;
    tier::PrettyPrint(s);
    s<<"Milchleistung: "<< kuh::Getliter()<<" Liter"<<endl;
    s<<"Fleischpreis: "<< kuh::Getfleischpreis()<<" Euro"<<endl;
    s<<"Milchpreis: "<<kuh::Getmilchpreis()<<" Euro"<<endl;
    s << "Wolle/Monat: " << wolle<<" kg" << endl;
    s<<"Wollpreis/kg: " << wollpreis<<" Euro"<<endl;
    s<< "Aktueller Wert: "<<wert()<<" Euro"<<endl;
    s<< "Beinanzahl: "<<vierbeiner::baz4%4+4<<endl<<endl;

}

ostream& operator<<(ostream& s, const schaf& rhs)
{
    rhs.PrettyPrint(s);
    return s;
}

//pute.h
#ifndef PUTE_H
#define PUTE_H

#include "zweibeiner.h"

class pute : public zweibeiner
{
    public:
        static int turkey;
        /** Default constructor */
        pute(const string Name, const datum Geburtsdatum, float Gewicht, float Fleischpreis);
        /** Default destructor */
        virtual ~pute();
        void PrettyPrint(ostream& s) const;
        float Getfleischpreis() const {return fleischpreis;}
        void Setfleischpreis(int val) { fleischpreis = val; }
        float wert()const {return fleischpreis*tier::Getkg();}
    protected:
    private:
    float fleischpreis;
};
ostream& operator<<(ostream& s, const pute& rhs);

#endif // PUTE_H

//pute.cpp
#include "pute.h"
int pute::turkey(0);
pute::pute(const string Name, const datum Geburtsdatum, float Gewicht, float Fleischpreis)
:zweibeiner(Name, Geburtsdatum, Gewicht), fleischpreis(Fleischpreis)
{
    turkey++;
    //ctor
}

pute::~pute()
{
    turkey--;
    //dtor
}

void pute::PrettyPrint(ostream& s) const
{
    s<< "Pute: "<<endl;
    tier::PrettyPrint(s);
    s<< "Fleischpreis: "<< pute::Getfleischpreis()<<" Euro"<<endl;
    s<< "Aktueller Wert: "<<wert()<<" Euro"<<endl;
    s<< "Beinanzahl: "<<zweibeiner::baz2%2+2<<endl<<endl;
}

ostream& operator<<(ostream& s, const pute& rhs)
{
    rhs.PrettyPrint(s);
    return s;
}

//huhn.h
#ifndef HUHN_H
#define HUHN_H

#include "pute.h"

class huhn : public pute
{
    public:
        static int chicken;
        /** Default constructor */
        huhn(const string Name, const datum Geburtsdatum, float Gewicht, float Fleischpreis, int Eier, float Eierpreis);
        /** Default destructor */
        virtual ~huhn();

        int Geteier() const { return eier; }
        void Seteier(int val) { eier = val; }
        int Geteierpreis() const { return eierpreis; }
        void Seteierpreis(int val) { eierpreis = val; }

        void PrettyPrint(ostream& s) const;

        float wert() const {return pute::wert()+eier*eierpreis;}
    protected:
    private:
        int eier; //!< Member variable "eier"
        float eierpreis;
};
ostream& operator<<(ostream& s, const huhn& rhs);

#endif // HUHN_H

//huhn.cpp
#include "huhn.h"
int huhn::chicken(0);
huhn::huhn(const string Name, const datum Geburtsdatum, float Gewicht, float Fleischpreis, int Eier, float Eierpreis)
:pute(Name, Geburtsdatum, Gewicht, Fleischpreis), eier(Eier), eierpreis(Eierpreis)
{
    pute::turkey--;
    chicken++;
    //ctor
}

huhn::~huhn()
{
    pute::turkey++;
    chicken--;
    //dtor
}

void huhn::PrettyPrint(ostream& s) const
{
    s<< "Huhn: "<< endl;
    tier::PrettyPrint(s);
    s<< "Fleischpreis: "<<pute::Getfleischpreis()<<" Euro"<<endl;
    s<< "Eier/Monat: " << eier<<" Stueck" << endl;
    s<< "Eierpreis: " << eierpreis<<" Euro" << endl;
    s<< "Aktueller Wert: "<<wert()<<" Euro"<<endl;
    s<< "Beinanzahl: "<<zweibeiner::baz2%2+2<<endl<<endl;
}

ostream& operator<<(ostream& s, const huhn& rhs)
{
    rhs.PrettyPrint(s);
    return s;
}

Es gibt noch mehrere Tierklassen. Aber das wäre zu viel zu posten. Wiederholt sich ja alles. Das Programm funktioniert so, aber wie schon in meinem vorherigen Post erwähnt funktioniert es so nur manchmal.

priesn schrieb:

sorry wegen des langen codes, aber ich hab nicht so viel zeit ihn zu reduzieren, da ich für die uni auch andere sachen machen muss

Glaubst du, jemand hat so viel Zeit, das alles zu lesen? Hier sind nur Freiwillige unterwegs. Meinst du, die nehmen sich für dich Zeit, wenn du keine Zeit/Lust für uns hast?