3. konto

konto

  • ?

    ich nicht ... sry

    0
  • ?
     

    konto.h:
--------

#ifndef __KONTOH__
#define __KONTOH__

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

class Konto
{
	private:
		std::string name;
		unsigned long kontonummer;
		float kontostand;
		float ueberziehungsrahmen;
		float ueberzogen;
		unsigned int bankleitzahl;
	public:
		Konto(const string& k_name, unsigned long k_nr, float k_stand, float u_rahmen, unsigned int blz);    // Konstruktor		
		void display();
		bool geld_Auszahlen(float auszahlung);
		void geld_Einzahlen(float einzahlung);
		void setUeberziehungsrahmen(float setueberziehungsrahmen);
		void setKontostand(float setbetrag);
		void setKontoinhaber(string setkontoinhaber);
		void setKontonummer(unsigned long setkontonummer);
		float getKontonummer();
};

class Kontoverwaltung
{
    private:
		vector<Konto> konten;
	public:
		void konto_Hinzufuegen(Konto& konto);
		void geld_Ueberweisen(unsigned long kontonummer_von, unsigned long kontonummer_nach, float betrag);
};

#endif

konto.cpp:
----------

#include "Konto.h"

Konto::Konto(const string& k_name, unsigned long k_nr, float k_stand, float u_rahmen, unsigned int blz):name(k_name),kontonummer(k_nr),kontostand(k_stand),ueberziehungsrahmen(u_rahmen),bankleitzahl(blz), ueberzogen(0) 
{}

void Konto::display()
{
	cout << "--------------------------------\n"
		 << "Kontoinhaber:  " << name.c_str()<< '\n'
		 << "Kontonummer:   " << kontonummer << '\n'
		 << "Kontostand:    " << kontostand  << '\n'
		 << "--------------------------------\n"
		 << endl;
}

void Konto::setKontostand(float setbetrag)
{
	kontostand = setbetrag;
}

void Konto::setUeberziehungsrahmen(float setueberziehungsrahmen)
{
	ueberziehungsrahmen = setueberziehungsrahmen;
}

void Konto::geld_Einzahlen(float einzahlung)
{
	kontostand += einzahlung;

    // wenn Kontostand negativ ist, und wieder Geld eingezahlt wurde, wird der ueberzogene Betrag aktualisiert
	if((ueberzogen >= ueberziehungsrahmen) && (kontostand < 0))
	{
		ueberzogen += einzahlung;
	}
	// wenn der Kontostand positiv ist, wird der ueberzogene Betrag auf 0 gesetzt
	else if(kontostand >= 0)
	{
		ueberzogen = 0;
	}
}

bool Konto::geld_Auszahlen(float auszahlung)
{
	if(kontostand >= auszahlung)
	{
		kontostand -= auszahlung;
		return true;
	} 
	// ueberpruefen ob noch ueberzogen werden kann
	else if(ueberzogen > ueberziehungsrahmen)
	{

		kontostand -= auszahlung;
		ueberzogen -= auszahlung;
		return true;
	}

	return false;
}

void Konto::setKontonummer(unsigned long setkontonummer)
{
	kontonummer = setkontonummer;
}

void Konto::setKontoinhaber(string setkontoinhaber)
{
	name = setkontoinhaber.c_str();
}

void Kontoverwaltung::konto_Hinzufuegen(Konto& konto)
{
	konten.push_back(konto);
}

float Konto::getKontonummer()
{
	 return kontonummer;
}

void Kontoverwaltung::geld_Ueberweisen(unsigned long kontonummer_von, unsigned long kontonummer_nach, float betrag)
{
	// Suchen eines Kontos
	for(vector<Konto>::iterator toFind = konten.begin(); toFind != konten.end(); ++toFind)
	if(toFind->getKontonummer() == kontonummer_von)
    break;

	if(toFind == konten.end())
    throw "Konto, von dem Geld ueberweisen werden sollte, nicht gefunden.\r\n";

	// damit findet man also den Iterator zu dem Konto, von dem das Geld abgehoben werden soll, den Code übernimmt man dann für die Klasse, zu der geschickt werden soll und dann hat man im Endeffekt zwei Iteratoren
	vector<Konto>::iterator konto_von = toFind;

}

konto-main.cpp:
---------------

#include "Konto.h"

int main()
{
	Kontoverwaltung verwaltung;

	Konto giro("Gerald", 1234567, 0.00f, -200.00f, 200);
	verwaltung.konto_Hinzufuegen(giro);

    Konto sparkonto("Steffi", 7654321, -2000.00f, 0.0f, 9500);
	verwaltung.konto_Hinzufuegen(sparkonto);

    giro.geld_Einzahlen(100);
    giro.geld_Auszahlen(100);
    giro.geld_Auszahlen(50);
	giro.geld_Auszahlen(50);
	giro.geld_Auszahlen(50);
	giro.geld_Auszahlen(50);
	giro.geld_Auszahlen(50);
	giro.geld_Einzahlen(50);
	giro.geld_Einzahlen(50);
	giro.geld_Einzahlen(50);
	giro.geld_Einzahlen(50);
	giro.geld_Einzahlen(50);
	giro.geld_Einzahlen(50);
	giro.geld_Auszahlen(50);
	giro.geld_Auszahlen(50);
	giro.geld_Auszahlen(50);
	giro.geld_Auszahlen(50);
	giro.geld_Auszahlen(50);
	giro.geld_Auszahlen(50);
	giro.geld_Auszahlen(50);

    // konten anzeigen
    giro.display();
    sparkonto.display(); 

    // Geld von giro Konto auf sparkonto ueberweisen
    verwaltung.geld_Ueberweisen(1234567, 7654321, 10);

    // konten anzeigen
    giro.display();
    sparkonto.display(); 

	return 0;
}

    ich hab nun den code bissal geändert...
    konzept:
    - eine weitere Klasse Kontoverwaltung schreibst.
    - Diese Klasse hat z.B. einen vector (oder welche Containerklasse auch immer) auf Konten.
    - Jedes erstellte Konto wird diesem vector (oder was auch immer) hinzugefügt
    - Die KLasse hat außerdem eine Funktion, die geld überweist auf ein Konto via Kontonummer
    - Um dies zu erreichen durchläuft sie den vector und vergleicht die Kontonummer jeder Klasse mit der übergebenen Kontonummer an geld_Ueberweisen

    ich weiß nimma wie ich da weiter komme in void Kontoverwaltung::geld_Ueberweisen...

    cu

    0
  • ?

    nimm doch lieber ne map für die Verwaltung.

    0
  • ?
     

    konto.h:
--------

#ifndef __KONTOH__
#define __KONTOH__

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

class Konto
{
	private:
		std::string name;
		unsigned long kontonummer;
		float kontostand;
		float ueberziehungsrahmen;
		unsigned int bankleitzahl;
	public:
		Konto(const string& k_name, unsigned long k_nr, float k_stand, float u_rahmen, unsigned int blz);    // Konstruktor		
		bool geld_Auszahlen(float auszahlung);
		void geld_Einzahlen(float einzahlung);
		void setUeberziehungsrahmen(float setueberziehungsrahmen);
		void setKontostand(float setbetrag);
		void setKontoinhaber(string setkontoinhaber);
		void setKontonummer(unsigned long setkontonummer);
		unsigned long getKontonummer();
		float getKontostand();
		void display();
};

class Kontoverwaltung
{
    private:
		// die map speichert das Konto zusammen mit der kontonummer, wobei die kontonummer als key (man könnte es auch als index ansehen) dient
		typedef std::map<unsigned long, Konto*> KontoMap;
		// ein map eintrag besteht aus 2 daten, einem key (first) und dem Object (second)
		KontoMap konten;
	public:
		void konto_Hinzufuegen(unsigned long kontonummer, Konto *konto);
		bool geld_Ueberweisen(unsigned long kontonummer_von, unsigned long kontonummer_nach, float betrag);
};

#endif

konto.cpp:
----------

#include "Konto.h"

Konto::Konto(const string& k_name, unsigned long k_nr, float k_stand, float u_rahmen, unsigned int blz):name(k_name),kontonummer(k_nr),kontostand(k_stand),ueberziehungsrahmen(u_rahmen),bankleitzahl(blz) 
{}

void Konto::display()
{
	cout << "--------------------------------\n"
		 << "Kontoinhaber:  " << name.c_str()<< '\n'
		 << "Kontonummer:   " << kontonummer << '\n'
		 << "Kontostand:    " << kontostand  << '\n'
		 << "--------------------------------\n"
		 << endl;
}

void Konto::setKontostand(float setbetrag)
{
	kontostand = setbetrag;
}

void Konto::setUeberziehungsrahmen(float setueberziehungsrahmen)
{
	ueberziehungsrahmen = setueberziehungsrahmen;
}

void Konto::geld_Einzahlen(float einzahlung)
{
	kontostand += einzahlung;
}

bool Konto::geld_Auszahlen(float auszahlung)
{
	// ueberpruefen ob der gewuenschte Betrag vom Konto abgebucht werden kann
	if ((kontostand + (-ueberziehungsrahmen) >= auszahlung))
	{
		kontostand -= auszahlung;
		return true;
	} 

	return false;
}

void Konto::setKontonummer(unsigned long setkontonummer)
{
	kontonummer = setkontonummer;
}

void Konto::setKontoinhaber(string setkontoinhaber)
{
	name = setkontoinhaber.c_str();
}

unsigned long Konto::getKontonummer()
{
	 return kontonummer;
}

float Konto::getKontostand()
{
	return kontostand;
}

void Kontoverwaltung::konto_Hinzufuegen(unsigned long kontonummer, Konto *konto) 
{
    // angenommen das konto existiert noch nicht, man sollte hier allerdings danach testen
    // und geeignet ne exception oder sowas werfen
    konten.insert (KontoMap::value_type (kontonummer, konto));   
}

bool Kontoverwaltung::geld_Ueberweisen(unsigned long kontonummer_von, unsigned long kontonummer_nach, float betrag)
{
    // der iterator ist dazu die inhalte einer map oder eines vektors direkt ansprechen zu koennen
	// man speichert zwar die objekte in einer map / vektor, aber direkt ansprechen lassen sie sich nur über die iteratoren
	KontoMap::iterator   itsource;
    KontoMap::iterator   itdest;

	// die map hat eine methode find, die den iterator auf das element zurueckgibt, sofern der key also in dem Fall die Kontonummer gefunden wird
    // itsource ist ein Iterator für KontoMap und kann auf Elemente innerhalb von KontoMap zeigen
	itsource = konten.find (kontonummer_von);
    itdest   = konten.find (kontonummer_nach);

	// beide konten muessen existieren
    if (itsource != konten.end () && itdest != konten.end ()) 
	{
        (itsource->second)->geld_Auszahlen(betrag);
        (itdest->second)->geld_Einzahlen(betrag);
		return true;
    } 
	else 
	{
        // falls transaktion nicht zulaessig ist, weil eines der konten nicht gueltig ist
        // oder die Ueberweisung wegen dem kontostand nicht klappt dann sollte
        // man darauf geeignet reagieren
		return false;
    }
}

konto-main.cpp:
---------------

#include "Konto.h"

int main()
{
	// Instanz der Klasse Kontoverwaltung erzeugen
	Kontoverwaltung *verwaltung = new Kontoverwaltung();

	// Instanz der Klasse Konto erzeugen
	Konto *giro = new Konto("Gerald", 23, 0.00f, -200.00f, 200);
	verwaltung->konto_Hinzufuegen(23, giro);

	// Instanz der Klasse Konto erzeugen
	Konto *sparkonto = new Konto("Steffi", 42, 0.00f, -200.0f, 9500);
	verwaltung->konto_Hinzufuegen(42, sparkonto);

	giro->geld_Einzahlen(100);
	sparkonto->geld_Einzahlen(100);

	// konten anzeigen
    giro->display();
	sparkonto->display(); 

	// Geld von giro Konto auf sparkonto ueberweisen
	verwaltung->geld_Ueberweisen(23, 42, 300);

	// konten anzeigen
	giro->display();
	sparkonto->display(); 

	// Instanzen der Klasse Konto loeschen
	delete sparkonto;
    delete giro;
    delete verwaltung;

	return 0;
}

    ok was sagt ihr nun? oder wäre das net besser doch mit vector?? bitte um comments!!

    cu surf. 😃

    0
  • ?

    diesen Namen solltest du ändern: __KONTOH__

    der ist schon für compiler reserviert wegen den unterstrichen.

    und war es nicht so das man using namespace std; nicht im header benutzen soll?

    0
  • ?

    ich soll __KONTOH__ in
    KONTOH__ ändern oder?

    und war es nicht so das man using namespace std; nicht im header benutzen soll?

    wo soll das using namespace dann hin?

    was ist der vorteil einer map gegenüber vector?

    cu surf.

    0
  • ?

    was ist der vorteil einer map gegenüber vector?

    Ist schneller beim Finden. map ist als Baum implementiert, vector als Array

    0
  • ?

    Ist schneller beim Finden. map ist als Baum implementiert, vector als Array

    was müsste ich in meinem prog ändern damit das als vector statt map funzt?

    cu

    0
  • ?

    @surf.:
    Die Implementierung einer Map ist bei dieser Aufgabenstellung aus den genannten Gründen wirklich vorzuziehen. Aber dem Mittelb**h wird es sowieso egal sein!

    Sinn deiner "Hausübung" ist es übrigens nicht, aus alles dem C++ Buch von PP&UKP abzuschreiben und sich den Rest der Arbeit hier im Forum vorkauen zu lassen. 👎

    ⚠ Denk mal darüber nach!

    0
  • ?

    @fhm.
    abgeschrieben wurde da gar nix, is das klaro!

    0
Anmelden zum Antworten