3. Kontoverwaltung

Kontoverwaltung

  • ?

    Ich brauche Hilfe für C++. Ich vestehe nicht C++. Jemandem kann mir helfen?

    Entwickeln Sie eine einfache Kontoverwaltung für eine Bank. Es gibt zwei verschiedene Arten von Konten: normale Konten und Girokonten. Da das Girokonto nur eine Variante eines normalenKontos ist, ist eine Klassenhierarchie sinnvoll.
    a) Klasse Konto Definieren Sie zuerst eine Klasse Konto, welche die Funktionalität einesnormalen Kontos implementiert. Ein Konto hat einen Inhaber (String) und einen aktuellenSaldo (float). Zudem bieten alle normalen Konten den gleichen Zinssatz (Hinweis: verwendenSie eine static Variable).
    Ein Konto kann eröffnet werden (mit einem Constructor), wobei der Name des Inhabers übergeben und der Saldo auf 0 gesetzt wird. Auf ein Konto kann etwas eingezahlt werden und von einem Konto kann etwas abgehoben werden (aber höchstens so viel, wie drauf ist!). Ebenfalls kann von einem Konto der Inhaber und der Saldo abgefragt werden. Auch der Zinssatz kann(für alle Konten gleichzeitig, also static) gesetzt werden und für ein konkretes Konto (also nicht static) jeweils abgefragt werden. Schliesslich ist für ein Konto noch der Ausgabeoperator« zu definieren, der den Inhaber, den Saldo und den Zinssatz eines Kontos auf dem Bildschirm ausgibt.
    b) Klasse Girokonto Leiten Sie von der Klasse Konto eine Klasse Girokonto ab. Ein Girokonto hat, im Gegensatz zu einem normalen Konto, ein Limit, bis zu dem es überzogen werden kann. Das Limit wird bei der Eröffnung des Girokontos angegeben. Beachten Sie, dass Sie wegen diesem Limit gegebenenfalls Methoden aus der Klasse Konto überschreiben müssen. Wie für normale Konten soll auch für das Girokonto gelten, dass der Zinssatz aller Girokonten gleich ist; er kann sich aber vom Zinssatz der normalen Konten unterscheiden. Dies implementieren Sie am besten, indem Sie die gleiche Zinssatz-Variable wie in der Klasse Konto erneut spezifizieren, wodurch die Variable von Konto verdeckt wird (Attribute Überschreiben).
    c) Hauptprogramm Um die verschiedenen Konto-Klassen zu testen, sollen Sie in der main-Funktion des Programms eine ganz einfache Bank implementieren, welche die Konten in einem Array verwaltet.
    Um beim Debugging Zeit zu sparen, sollten Sie während der Ausführung des Programms keinen Input über die Tastatur eingeben müssen. Initialisieren Sie stattdessen direkt in der main-Funktion einige Konten mit sinnvollen Daten und manipulieren Sie anschliessend die Konten ebenfalls in der main- Funktion. Führen Sie dabei die unten angegebenen Schritte aus und geben Sie nach jedem Schritt alle Konten aus (für jedes Konto jeweils Inhaber, Kontostand,Zinssatz und bei Girokonten zusätzlich die Limite), um die Korrektheit der einzelnen Schritte zu überprüfen. Achten Sie auch darauf, ob Polymorphismus in Ihrem Programm wirklich funktioniert, d.h. ob zum Beispiel die Girokonten, auf welche mit einem Pointer vom Typ Konto* zugegriffen wird, wirklich den Zinssatz von Girokonten und nicht den von normalen Konten anzeigen.
    • Erzeugen Sie ein paar Konten und Girokonten und zahlen Sie Geld auf alle Konten ein.(Konto *bank[6];)
    • Setzen Sie den Zinssatz für Konten zB auf 3% (das geht in einer Programmzeile) und denjenigen für Girokonten zB auf 5% (ebenfalls in einer Zeile).
    • Heben Sie von allen Konten Geld ab; kontrollieren Sie insbesondere, ob die Limits nicht überschritten werden.
    • Zahlen Sie erneut Geld auf alle Konten ein.
    • Simulieren Sie einen Banktag, indem Sie jedem Konto den Zins für einen Tag gutschreiben. (Ein Bankjahr hat 360 Tage).

    0
  • ?

    dkv schrieb:

    Ich brauche Hilfe für C++. Ich vestehe nicht C++. Jemandem kann mir helfen?

    eine etage tiefer bitte, da lungern die C++ fans rum *fg*
    🙂

    0
  • ?

    ja ich weiß der post ist schon bischen her aber mir war langweilig, und da dacht ich mir ich machs mal in c 😉

    #include <stdio.h>
#include <stdlib.h>

/////////////////////////////////////////////////////////////////////
//
//                 defines
//
#define CLS_KONTO(x) (*((konto*)(x)))
#define CLS_GIRO(x) (*((giroKonto*)(x)))
#define EACH_ACCOUNTS(a,b,c) \
	eachAccounts(#c,a,b,c)

/////////////////////////////////////////////////////////////////////
//
//                 structs
//
typedef struct _bank{
	int length;
	void *konten[6];
}bank;

struct _konto;
struct _giroKonto;

#define OOP_KONTO_METHODS\
	void (*contruct)();\
	void (*destruct)();\
	double (*getZins)(void *k);\
	void (*einzahlen)(void *,double val);\
	int (*auszahlen)(void *,double val);\
	void (*simulateDay)(void *k);\
	void (*get)(void *);\
	double zins

#define OOP_KONTO_VARS(cls)\
	cls *class;\
	char *name;\
	double saldo

typedef struct _kontoMethods{
	OOP_KONTO_METHODS;
	void (*set)(struct _konto *,char *,double);
}kontoMethods;

typedef struct _giroKontoMethods{
	OOP_KONTO_METHODS;
	void (*set)(struct _giroKonto *,char *,double,double);
	double zinsNeg;//7%
}giroKontoMethods;

typedef struct _konto{
	OOP_KONTO_VARS(kontoMethods);
}konto;

typedef struct _giroKonto{
	OOP_KONTO_VARS(giroKontoMethods);
	double limit;
}giroKonto;

/////////////////////////////////////////////////////////////////////
//
//                 konto class methods
//
double getZins(void *kk){
	konto *k = kk;
	return k->class->zins*36000;
}
void setKonto(konto *k,char *name,double val){
	k->name = name;
	k->saldo = val;
}
void getKonto(void *kk){
	konto *k=kk;
	printf(
		"name:%12s\t"
		"saldo: %f\t"
		"zins: %f\t"
		,k->name
		,k->saldo
		,k->class->getZins(k)
	);
}
void einzahlen(void *kk,double val){
	konto *k = kk;
	k->saldo += val;
}
int auszahlen(void *kk,double val){
	konto *k = kk;
	if(k->saldo >= val){
		k->saldo -= val;
		return 1;
	}
	return 0;
}
void calcCashDayKonto(void *kk){
	konto *k = kk;
	k->saldo += (k->saldo)*(k->class->zins);
}

kontoMethods kontoMethodsFn = {
		.getZins = &getZins
		,.get = &getKonto
		,.set = &setKonto
		,.einzahlen = &einzahlen
		,.auszahlen = &auszahlen
		,.simulateDay = &calcCashDayKonto
};

konto *new_konto(){
	konto *ret = calloc(1,sizeof(konto));
	if(!ret)
		return 0;
	ret->class = &kontoMethodsFn;
	return ret;
}

/////////////////////////////////////////////////////////////////////
//
//                giro konto class methods
//
void getKontoGiro(void *kk){
	giroKonto *k = kk;
	getKonto(k);
	printf(
		"limit: %f\t"
		,k->limit
	);
}
void setKontoGiro(giroKonto *k,char *name,double val,double limit){
	setKonto((konto*)k,name,val);
	k->limit = -limit;
}
int auszahlenGiro(void *kk,double val){
	giroKonto *k = kk;
	if(k->saldo + (-k->limit) >= val){
		k->saldo -= val;
		return 1;
	}
	return 0;
}
void calcCashDayGiroKonto(void *kk){
	giroKonto *k = kk;
	if(k->saldo>0)
		k->saldo += k->saldo * k->class->zins;
	if(k->saldo<0){
		k->saldo += k->saldo * k->class->zinsNeg;
		if(k->saldo < k->limit){
			printf("scheint das ist ein schufa eintrag;)\n");
		}
	}
}

giroKontoMethods giroKontoMethodsFn = {
		.getZins = &getZins
		,.get = &getKontoGiro
		,.set = &setKontoGiro
		,.einzahlen = &einzahlen
		,.auszahlen = &auszahlenGiro
		,.simulateDay = &calcCashDayGiroKonto
};

giroKonto *new_giroKonto(){
	giroKonto *ret = calloc(1,sizeof(giroKonto));
	if(!ret)
		return 0;
	ret->class = &giroKontoMethodsFn;
	return ret;
}

/////////////////////////////////////////////////////////////////////
//
//                 plot und main() helper fn
//
void eachPlot(void *kk){
	konto *k = kk;
	k->class->get(k);
}
void eachAuszahlen(void *kk){
	konto *k = kk;
	double val = 3;
	if(!k->class->auszahlen(k,val)){
		if(k->saldo >= 0){
			printf("name:%12s auszahlung von %f nicht moeglich max. %f\n"
				,k->name
				,val
				,k->saldo
			);
		}else{
			printf("name:%12s auszahlung von %f nicht moeglich max. %f\n"
				,k->name
				,val
				,k->saldo - ((giroKonto *)k)->limit
			);
		}
	}
}

void eachSimulate(void *kk){
	konto *k = kk;
	k->class->simulateDay(k);
}

void eachEinzahlen(void *kk){
	konto *k = kk;
	k->class->einzahlen(k,2);
}

void eachAccounts(char *info,bank *b,int newLine,void (*callback)(void*)){
	int l = 0;
	printf(	"----------------------------------"
			"%12s"
			"----------------------------------"
			"\n",info
	);
	while(l < b->length){
		callback(b->konten[l++]);
		if(newLine)
			printf("\n");
	}
}

/////////////////////////////////////////////////////////////////////
//
//
//
int main(void) {
	bank lolo = {0};

	kontoMethodsFn.zins = (3./100.)*(1./360.);
	giroKontoMethodsFn.zins = (5./100.)*(1./360.);
	giroKontoMethodsFn.zinsNeg = (10./100.)*(1./360.);

	lolo.konten[0] = new_konto();
	lolo.konten[1] = new_konto();
	lolo.konten[2] = new_konto();

	lolo.konten[3] = new_giroKonto();
	lolo.konten[4] = new_giroKonto();
	lolo.konten[5] = new_giroKonto();

	lolo.length = 6;

	CLS_KONTO(lolo.konten[0]).class->set(lolo.konten[0],"a",1);
	CLS_KONTO(lolo.konten[1]).class->set(lolo.konten[1],"b",2);
	CLS_KONTO(lolo.konten[2]).class->set(lolo.konten[2],"c",3);
	CLS_GIRO(lolo.konten[3]).class->set(lolo.konten[3],"d",4,2);
	CLS_GIRO(lolo.konten[4]).class->set(lolo.konten[4],"e",5,4);
	CLS_GIRO(lolo.konten[5]).class->set(lolo.konten[5],"f",6,8);

	EACH_ACCOUNTS(&lolo,1,eachPlot);
	EACH_ACCOUNTS(&lolo,0,eachAuszahlen);
	EACH_ACCOUNTS(&lolo,1,eachPlot);
	EACH_ACCOUNTS(&lolo,0,eachAuszahlen);
	EACH_ACCOUNTS(&lolo,1,eachPlot);
	EACH_ACCOUNTS(&lolo,0,eachAuszahlen);
	EACH_ACCOUNTS(&lolo,1,eachPlot);
	EACH_ACCOUNTS(&lolo,0,eachAuszahlen);
	EACH_ACCOUNTS(&lolo,1,eachPlot);
	EACH_ACCOUNTS(&lolo,0,eachAuszahlen);
	EACH_ACCOUNTS(&lolo,1,eachPlot);
	EACH_ACCOUNTS(&lolo,0,eachEinzahlen);
	EACH_ACCOUNTS(&lolo,1,eachPlot);

	//simulate a day
	EACH_ACCOUNTS(&lolo,0,eachSimulate);
	EACH_ACCOUNTS(&lolo,1,eachPlot);
	//sim rest of year
	int i=359;
	while(i--){
		EACH_ACCOUNTS(&lolo,0,eachSimulate);
	}
	EACH_ACCOUNTS(&lolo,1,eachPlot);

	return 0;
}

    lg lolo

    0
  • C

    Dieser Thread wurde von Moderator/in rüdiger aus dem Forum ANSI C in das Forum C++ verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.

    0
Anmelden zum Antworten