Blir ingen utdata

Hej hej, sitter och jobbar med ett projekt för skolan och har kommit rätt långt men när jag kör det så funkar det men ingen utdata kommer ut på skärmen men programmet byggs som det ska.

Programmet går ut på att det ska läsa indata och sen räkna ihop allas kostnader och fördela de på vem som är skyldig vem vad.

Man ska läsa in från en fil som heter resa.txt

Detta är vad som finns i filen resa.txt

050615 transp Eva 6000 5 Bosse Kristin Paul Torsten Stina
050721 mat Eva 300 2 Bosse Kristin
050721 mat Paul 400 2 Torsten Stina
050721 transp Bosse 5000 3 Eva Kristin Paul
050721 transp Stina 5000 1 Torsten
050722 boende Kristin 200 1 Eva
050722 mat Eva 300 2 Kristin Bosse
050723 mat Torsten 300 2 Paul Stina
050724 mat Paul 200 1 Stina
050725 transp Eva 600 3 Bosse Kristin Paul

#include <iostream>

#include <fstream>

#include <string>

#include <iomanip>

using namespace std;

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

//Globala konstanter

const int MAX_KOMPISAR = 10;

const int MAX_PERSONER = 10;

const int MAX_TRANSAKTIONER = 30;

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

//Klassdeklarationer

// Lagrar en persons sammanlagda transaktionsdata

class Person

{

private:

    string namn;

    double betalat_andras;   // Hur nycket man ligger ute med för andra

    double skyldig;          // Hur mycket man är skyldig andra

public:

    Person();

    Person(string n, double b, double s);

    double haemta_betalat();

    double haemta_skyldig();

    string haemta_namn();

    void skrivUt();

};

//Håller ordning på unika personer, dvs dess namn och transaktionsdata

class PersonLista

{

private:

    int antal_pers;

    Person pers[MAX_PERSONER];

public:

    PersonLista();

    ~PersonLista();

    void laggTillEn(Person pny);

    void skrivUtOchFixa();

    double summaSkyldig();

    double summaBetalat();

    bool finnsPerson(string namnet);          //bool finnsPerson(const                                                        string& namn);

};

// Lagrar data om en viss transaktion

class Transaktion

{

private:

    string datum;

    string typ;

    string namn;

    double belopp;

    int ant_kompisar;

    string kompisar[MAX_KOMPISAR];

public:

    Transaktion();

    ~Transaktion();

    string haemta_namn();

    double hamtabelopp();

    int haemta_ant_kompisar();

    bool finnsKompis(string namnet);

    bool laesEnTrans(istream &is);

    void skrivEnTrans(ostream &os);

    //Div annat:

    double haemta_skyldig(string namnet);

};

// Lagrar data om alla transaktioner (kvitton)

class TransaktionsLista

{

private:

    Transaktion trans[MAX_TRANSAKTIONER];

    int antalTrans;

public:

    TransaktionsLista();

    ~TransaktionsLista();

    void laesin(istream &is);

    void skrivut(ostream &os);

    void laggTill(Transaktion &t);

    double totalkostnad();

    double liggerUteMed(string namnet);

    double aerSkyldig(string namnet);

    PersonLista FixaPersoner();

};

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

//Deklaration av externa funktioner

void Meny (TransaktionsLista & translista, PersonLista & perslista);

void visaMeny ();

int Val();

// Huvudprogram:

int main()

{

    TransaktionsLista translista;

    PersonLista perslista;

    ifstream infil ("resa.txt");

    translista.laesin (infil);

    infil.close ();

    Meny (translista, perslista);

    return 0;

}

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

//Definition av externa funktioner

 void Meny (TransaktionsLista & translista, PersonLista & perslista)

 {

   Transaktion tn;

   Person pers;

   int antal = 0;

   string namnet;

   int val = -1;

   ifstream infil ("resa.txt");

   ofstream utfil ("ny.txt", ios_base::app);

   while (val != 0)

     {

       visaMeny ();

       val = Val();

       switch (val)

     {

     case 0:

       cout << "\nProgrammet avslutas. Tillagda transaktioner sparas." <<

         endl;

       translista.skrivut (utfil);

       utfil.close ();

       break;

     case 1:

       tn.laesEnTrans (cin);

       translista.laggTill (tn);

       break;

     case 2:

       cout << "\nAntal trans = " << antal << endl;

       translista.skrivut (cout);

       cout << endl;

       break;

     case 3:

       cout << "\nAktivitetens totalkostnad: " << translista.

         totalkostnad () << " kr." << endl << endl;

       break;

     case 4:

       cout << "Ange namn: ";

       cin >> namnet;

       cout << namnet << " är skyldig: " << translista.

         aerSkyldig (namnet) << " kr." << endl << endl;

       break;

     case 5:

       cout << "Ange namn: ";

       cin >> namnet;

       cout << namnet << " ligger ute med: " << translista.liggerUteMed (namnet) << " kr." << endl << endl;

       break;

     case 6:

       perslista = translista.FixaPersoner ();

       perslista.skrivUtOchFixa ();

       cout << endl;

       break;

     }

     }

 }

// Funktion som skriver ut menyn

void visaMeny ()

{

  cout << "-------------> Väj funktion <-------------" << endl << endl;

  cout << "0. Avsluta. Alla transaktioner sparas på fil." << endl;

  cout << "1. Läs in en transaktion från tangentbordet." << endl;

  cout << "2. Skriv ut information om alla transaktioner." << endl;

  cout << "3. Beräkna totala kostnaden." << endl;

  cout << "4. Hur mycket är en viss person skyldig?" << endl;

  cout << "5. Hur mycket ligger en viss person ute med?" << endl;

  cout << "6. Lista alla personer mm och FIXA!" << endl << endl;

}

int Val ()

{

  int val;

  cout << "Välj funktion: ";

  cin >> val;

  return val;

}

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

//Definition av metoder i alla de fyra klasserna

//------------Metoder i klassen Person------------

// Konstruktor

Person::Person()

{

    namn = "";

    betalat_andras = 0.0;

    skyldig = 0.0;

}

// Överlagrad konstruktor

Person::Person(string n, double b, double s)

{

    namn = n;

    betalat_andras = b;

    skyldig = s;

}

// Selektorer

double Person::haemta_betalat()

{

    return betalat_andras;

}

double Person::haemta_skyldig()

{

    return skyldig;

}

string Person::haemta_namn()

{

    return namn;

}

// Skriver ut information om en en specifik persons utlägg och skulder

void Person::skrivUt()

{

    if(betalat_andras > skyldig)

    {

        cout << namn << " ligger ute med " << setiosflags(ios::fixed)

             << setprecision(0) << betalat_andras << ", är skyldig "

             << setiosflags(ios::fixed) << setprecision(0) << skyldig

             << " och ska ha " << setiosflags(ios::fixed) << setprecision(0)

             << betalat_andras - skyldig << " från potten!" << endl;

    }

    else

    {

        cout << namn << " ligger ute med " << setiosflags(ios::fixed)

             << setprecision(0) << betalat_andras << ", är skyldig "

             << setiosflags(ios::fixed) << setprecision(0) << skyldig

             << " och ska betala " << setiosflags(ios::fixed) << setprecision(0)

             << skyldig - betalat_andras << " till potten!" << endl;

    }

}

//------------Metoder i klassen PersonLista------------

// Konstruktor

PersonLista::PersonLista()

{

    antal_pers = 0;

}

// Destruktor

PersonLista::~PersonLista()

{

}

// Lägger till en ny person till arrayen pers[]

void PersonLista::laggTillEn(Person pny)

{

    pers[antal_pers] = pny;

    antal_pers++;

}

// Skriver ut info om varje personobjekt i arrayen pers[]

void PersonLista::skrivUtOchFixa()

{

    for(int i = 0; i < antal_pers; i++)

    {

        pers[i].skrivUt();

    }

}

// Summan av alla skulder för en specifik person beräknas

double PersonLista::summaSkyldig()

{

    double skyldig = 0.0;

    for(int i = 0; i < antal_pers; i++)

    {

        skyldig += pers[i].haemta_skyldig();

    }

    return skyldig;

}

// Summan av alla utlägg för en given person beräknas

double PersonLista::summaBetalat()

{

    double betalat = 0.0;

    for(int i = 0; i < antal_pers; i++)

    {

        betalat += pers[i].haemta_betalat();

    }

    return betalat;

}

// Kontrollerar med bool om det givna namnet finns i personarrayen

bool PersonLista::finnsPerson(string namnet)

{

    for(int i = 0; i < MAX_PERSONER; i++)

    {

        if(pers[i].haemta_namn() == namnet)

        {

            return true;

}

    }

    return false;

}

//------------Metoder i klassen Transaktion------------

// Konstruktor

Transaktion::Transaktion()

{

    datum = "";

    typ = "";

    namn = "";

    belopp = 0.0;

    ant_kompisar = 0;

    for(int i = 0; i < MAX_KOMPISAR; i++)

    {

        kompisar[i] = "";

    }

}

// Destruktor

Transaktion::~Transaktion()

{

}

// Selektorer

string Transaktion::haemta_namn()

{

    return namn;

}

double Transaktion::hamtabelopp()

{

    return belopp;

}

int Transaktion::haemta_ant_kompisar()

{

    return ant_kompisar;

}

double Transaktion::haemta_skyldig(string namnet)

{

    double skuld = 0.0;

    for(int i = 0; i < ant_kompisar; i++)

    {

        if(kompisar[i] == namnet)

        {

            skuld = belopp / (ant_kompisar + 1);

        }

    }

    return skuld;

}

// Returnerar true om namnet finns i arrayen kompisar

bool Transaktion::finnsKompis(string namnet)

{

    for(int i = 0; i < MAX_KOMPISAR; i++)

    {

        if(kompisar[i].find(namnet, 0) != std::string::npos)

            return true;

    }

    return false;

}

// Läser in en transaktion

   bool Transaktion:: laesEnTrans( istream &is )

    {

      is >> datum >>  typ >> namn >> belopp >> ant_kompisar;

      if(0 < ant_kompisar){

            for(int i = 0; i < ant_kompisar; i++)

            {

                is >> kompisar[i];

                if ( is.eof() ) return false;

            }

         }

      return true;

    }

// Skriver ut information om ett transaktionsobjekt

void Transaktion::skrivEnTrans(ostream &os)

{

    os << datum << "\t" << typ << "\t" << namn << "\t" << belopp << "\t" << ant_kompisar

        << "\t";

    for(int i = 0; i < ant_kompisar; i++)

        os << kompisar[i] << "\t";

    os << endl;

}

//------------Metoder i klassen TransaktionsLista------------

// Konstruktor

TransaktionsLista::TransaktionsLista()

{

    antalTrans = 0;

}

// Destruktor

TransaktionsLista::~TransaktionsLista()

{

}

// Använder Transaktion::laesEnTrans och TransaktionsLista::laggTill för att läsa

// in data till arrayen trans[]

void TransaktionsLista::laesin(istream &is)

{

    Transaktion t;

    while(t.laesEnTrans(is))        // Så länge det finns rader kvar att läsa i infil

    {

        laggTill(t);

    }

}

// Använder Transaktion::skrivEnTrans för att skriva ut info om samtliga

// transaktionsobjekt i arrayen trans[]

void TransaktionsLista::skrivut(ostream &os)

{

    for(int i = 0; i < antalTrans; i++)

    {

        trans[i].skrivEnTrans(os);

    }

}

// Lägger till aktuellt objekt sist i arrayen trans[]

void TransaktionsLista::laggTill(Transaktion &t)

{

    trans[antalTrans] = t;

    antalTrans++;

}

// Beräknar summan av resans totala kostnader

double TransaktionsLista::totalkostnad()

{

    double totalkostnad = 0;

    for(int i = 0; i < antalTrans; i++)

    {

        totalkostnad += trans[i].hamtabelopp();

    }

    return totalkostnad;

}

// Beräknar hur mycket en specifik person ligger ute med

double TransaktionsLista::liggerUteMed(string namnet)

{

    double betalat = 0.0;

    for(int i = 0; i < antalTrans; i++)

    {

        if(trans[i].haemta_namn() == namnet)

            betalat += (trans[i].hamtabelopp() - (trans[i].hamtabelopp() /

                       (trans[i].haemta_ant_kompisar() + 1)));

    }

    return betalat;

}

// Beräknar hur mycket en specifik person är skyldig att betala i potten

double TransaktionsLista::aerSkyldig(string namnet)

{

    double skyldig = 0.0;

    for(int i = 0; i < antalTrans; i++)

    {

        if (trans[i].finnsKompis(namnet))

            skyldig += trans[i].haemta_skyldig(namnet);

    }

    return skyldig ;

}

// Skapar ett PersonList-objekt med data om en specifik persons transaktioner

PersonLista TransaktionsLista::FixaPersoner()

{

    PersonLista perslista;

    string persnamn;

    double persskuld=0;

    double persbetalat=0;

    for(int i = 0; i < antalTrans; i++)

    {

        if(!perslista.finnsPerson(trans[i].haemta_namn()))

        {

            persnamn = trans[i].haemta_namn();

            persskuld += aerSkyldig(persnamn);

            persbetalat += liggerUteMed(persnamn);

            Person nypers = Person(persnamn, persbetalat, persskuld);

            perslista.laggTillEn(nypers);

        }

    }

    return perslista;

}