*Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!



  • Grüßt euch,

    ich hänge an einer, vermutlich einfachen, Methode zur Erstellung eines Bankkontos. Die einzigen Bedingungen:

    • Kontonummer muss einmalig sein
    • Konto kann erst eröffnet werden, wenn eine Person erstellt wurde.

    Soweit so gut. Person erstellen klappt, wird auch in einem Vektor gespeichert.
    Allerdings funktioniert meine Methode, zur Erstellung eines Kontos nicht richtig.

    class Bank {
    
    private:
        vector<Person> person;
        vector<Account> account;
    
    
    public:
        void menu();
        void createUser(string vorname, string nachname, int tag, int monat, int jahr);
        void createAccount(int kontonr, double kontostand, Person* p1);
        vector<Person> get_person() const;
        vector<Account> get_account() const;
        void print_person();
        void print_account();
    
    
    
    };
    
    #include "Bank.h"
    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    void Bank::menu() {
    
        Bank bank1;
        Person *p1;
        string vorname;
        string nachname;
        int tag;
        int monat;
        int jahr;
    
        bool end = false;
        do {
            int eingabe;
    
            cout << "1. Alle Kundendaten anzeigen" << endl;
            cout << "2. Alle Konten anzeigen" << endl;
            cout << "3. Neuen Kunden anlegen (ohne Konto)" << endl;
            cout << "4. Neues Konto anlegen (Kunde muss existieren)" << endl;
            cout << "5. Neue Buchung" << endl;
            cout << "6. Kontoauszug fuer Konto ziehen" << endl;
            cout << "7. Ein Konto aufloesen" << endl;
            cout << "8. Testdaten einfuegen" << endl;
            cout << "9. Zum beenden q eingeben" << endl;
            cout << endl;
            cin >> eingabe;
    
    
            switch (eingabe) {
    
                case 1: {
    
                    bank1.print_person();
                    break;
                }
    
                case 2: {
                    bank1.print_account();
                    break;
                }
    
                case 3: {
    
                    cout << "Bitte Vorname, Nachname, Tag, Monat und Jahr angeben: " << endl;
                    cin >> vorname >> nachname >> tag >> monat >> jahr;
    
                    bank1.createUser(vorname, nachname, tag, monat, jahr);
                    cout << endl;
                    break;
                }
                case 4: {
                    cout << "Bitte Vorname, Nachname, Tag, Monat und Jahr angeben: " << endl;
                    cin >> vorname >> nachname >> tag >> monat >> jahr;
                    string nachname;
                    int kontonr;
                    double kontostand = 100.0;
    
                    //1.Benutzer finden
                    //2.pointer auf benutzer
                    //3.createacc
    
                    cout << "Geben Sie eine eindeutige Kontonummer ein und den Nachnamen der Person: " << endl;
                    cin >> kontonr >> nachname;
    
                    bank1.createAccount(kontonr, kontostand, p1);
                    bank1.print_account();
                    break;
    
    
                }
            }
        } while (!end);
    
    }
    
    void Bank::createUser(string vorname, string nachname, int tag, int monat, int jahr) {
    
        bool found = true;
    
        for (unsigned int i = 0; i < this->person.size(); i++) {
    
            if (nachname == this->person.at(i).get_nachname()) {
    
                cout << "ERROR: Nachname ist bereits vorhanden!";
                found = false;
    
            }
        }
    
        if (found) {
    
            this->person.push_back(Person(vorname, nachname, tag, monat, jahr));
        }
    }
    
    void Bank::createAccount(int kontonr, double kontostand, Person* p1) {
    
            bool kontonr_found = true;
            bool person_found = false;
    
            for (unsigned int i = 0; i < this->person.size(); i++) {
    
                string nachname;
    
                if ( nachname == this->person.at(i).get_nachname() ) {
    
                    person_found = true;
                }
            }
    
            for (unsigned int j = 0; j < this->account.size(); j++) {
    
                if ( kontonr == this->account.at(j).get_kontonummer() ) {
    
                    cout << "ERROR: Kontonummer existiert bereits!";
                    kontonr_found = false;
                }
            }
    
            if ( kontonr_found && person_found  ) {
    
                this->account.push_back(Account(kontonr, kontostand, p1));
            }
    
    }
    
    void Bank::print_person() {
    
        for (unsigned int i = 0; i < this->person.size(); i++) {
    
            this->person.at(i).print();
        }
    }
    
    void Bank::print_account() {
    
        for (unsigned int i = 0; i < this->account.size(); i++) {
    
            this->account.at(i).print();
        }
    
    }
    
    vector<Person> Bank::get_person() const {
    
        return this->person;
    }
    
    vector<Account> Bank::get_account() const {
    
        return this->account;
    }
    

    Das ist ein ziemlich primitiver Code, aber ich möchte ihn erstmal einfach halten. Die Skills kommen mit der Zeit.

    Meine Idee für eine Lösung:

    1. Den Vektor <Personen> durch iterieren und prüfen, ob der eingegebene Name des Benutzers im Vektor enthalten ist.
      Wenn ja Step 2.
    2. Den Vektor <Account> durch iterieren, um zu gucken, ob bereits eine Kontonummer existiert, die der Benutzer selber bestimmen darf.
      An dieser Stelle merke ich an, dass es bestimmt automatisierte Verfahren zur Erzeugung individueller Nummern gibt, die nur einmal zugeordnet werden, aber ich möchte es wie gesagt primitiv halten und dementsprechend eine Bedingung implementieren, die prüft, ob die Nummer vorhanden ist.
    3. Sollten alle Bedingungen erfüllt worden sein, soll ein Account angelegt und im Vektor gespeichert werden.

    Wichtig: Die Klasse Account besitzt drei Parameter: int kontonr, double kontostand, Person* p1

    Was habe ich vergessen - nicht beachtet?



  • @Suprax sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    Was habe ich vergessen - nicht beachtet?

    Dein Problem verständlich zu beschreiben.



  • @manni66

    Tschuldige.

    Mein Problem ist, dass ich in Case 4 die Methode createAccount implementiert habe, sie allerdings nicht funktioniert und ich logisch nicht mehr voran komme.



  • Überlege doch mal, wo du die erstellen Personen speicherst und was du der Methode createAccount übergibst.



  • @daddy_felix Die erzeugten Personen speichere ich im Vektor<Personen>.
    In der Methode createAccount übergebe ich einen Zeiger auf ein Objekt der Klasse Personen.


  • Mod

    @Suprax sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    In der Methode createAccount übergebe ich einen Zeiger auf ein Objekt der Klasse Personen.

    Das ist eine Beschreibung des Typs der Übergabe. Das heißt quasi nur, dein Programm ist grammatikalisch korrekt. Aber das heißt nicht, dass es Sinn ergibt. Was ist deiner Meinung nach der Inhalt? Sprich: Dieser Zeiger, von dem du sprichst, worauf zeigt der?



  • @SeppJ der Zeiger zeigt auf das Objekt p1, das eine Instanz der Klasse Person ist.

    Rein von der Logik betrachtet müsste ich ein Verweis aus Objekten einer Klasse anlegen und diesen Verweis dem Vektor<Account> am Ende der Methode mittels push_back übergeben, oder?



  • @Suprax sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    @SeppJ der Zeiger zeigt auf das Objekt p1, das eine Instanz der Klasse Person ist.

    An welcher Stelle wird denn der Zeiger p1 auf eine Instanz der Klasse Person gesetzt?
    Edit:
    Anders: p1 IST doch ein Zeiger und kein Objekt, auf das ein Zeiger zeigen würde!


  • Mod

    @Suprax sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    @SeppJ der Zeiger zeigt auf das Objekt p1, das eine Instanz der Klasse Person ist.

    Nee, du denkst wieder nur in Typen. Ich will wissen, auf welches Person-Objekt p1 deiner Meinung nach zeigt, nicht ob p1 prinzipiell geeignet wäre, auf Objekte dieses Typs zu zeigen.

    Rein von der Logik betrachtet müsste ich ein Verweis aus Objekten einer Klasse anlegen und diesen Verweis dem Vektor<Account> am Ende der Methode mittels push_back übergeben, oder?

    Vielleicht. Ich verstehe nicht, was du hier beschreiben möchtest, aber tendenziell scheinst du langsam zu verstehen, was das Problem ist.

    Wie auch immer: Selbst wenn du dieses Problem nun löst, wirst du direkt ein anderes Problem bekommen: Die Adresse von Objekten in einem Vector ist nicht konstant. Wenn du einen Zeiger auf ein Objekt in einem Vector hast, dann etwas an dem Vector änderst, und danach den Zeiger noch einmal benutzen möchtest, dann geht das nicht. Wenn neue Personen zu der Bank kommen, dann funktionieren die alten Konten nicht mehr. Was du eigentlich möchtest ist gar kein Zeiger, sondern ein Verweis auf die Position im Vector. Also den Index, an dem die Person steht. Natürlich vorausgesetzt, dass du niemals Personen entfernst!

    Sichtbare Zeiger sind in modernem C++ sowieso total selten, es sollte immer ein Alarmzeichen sein, wenn man einen nutzt, dass es wahrscheinlich auch besser ginge.



  • @Belli sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    @Suprax sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    @SeppJ der Zeiger zeigt auf das Objekt p1, das eine Instanz der Klasse Person ist.

    An welcher Stelle wird denn der Zeiger p1 auf eine Instanz der Klasse Person gesetzt?
    Edit:
    Anders: p1 IST doch ein Zeiger und kein Objekt, auf das ein Zeiger zeigen würde!

    @SeppJ sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    @Suprax sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    @SeppJ der Zeiger zeigt auf das Objekt p1, das eine Instanz der Klasse Person ist.

    Nee, du denkst wieder nur in Typen. Ich will wissen, auf welches Person-Objekt p1 deiner Meinung nach zeigt, nicht ob p1 prinzipiell geeignet wäre, auf Objekte dieses Typs zu zeigen.

    Rein von der Logik betrachtet müsste ich ein Verweis aus Objekten einer Klasse anlegen und diesen Verweis dem Vektor<Account> am Ende der Methode mittels push_back übergeben, oder?

    Vielleicht. Ich verstehe nicht, was du hier beschreiben möchtest, aber tendenziell scheinst du langsam zu verstehen, was das Problem ist.

    Wie auch immer: Selbst wenn du dieses Problem nun löst, wirst du direkt ein anderes Problem bekommen: Die Adresse von Objekten in einem Vector ist nicht konstant. Wenn du einen Zeiger auf ein Objekt in einem Vector hast, dann etwas an dem Vector änderst, und danach den Zeiger noch einmal benutzen möchtest, dann geht das nicht. Wenn neue Personen zu der Bank kommen, dann funktionieren die alten Konten nicht mehr. Was du eigentlich möchtest ist gar kein Zeiger, sondern ein Verweis auf die Position im Vector. Also den Index, an dem die Person steht. Natürlich vorausgesetzt, dass du niemals Personen entfernst!

    Sichtbare Zeiger sind in modernem C++ sowieso total selten, es sollte immer ein Alarmzeichen sein, wenn man einen nutzt, dass es wahrscheinlich auch besser ginge.

    Wenn ich drüber nachdenke, dann eigentlich auf gar kein Objekt, bzw. ein leeres Objekt, oder?

    Ich verstehe das soweit von der Logik her, bzgl. der Adressierung. Dein Ansatz ist definitiv richtig, das sehe ich auch an den Aufgabenstellungen.
    Ich möchte also ein Verweis auf die Position im Vector. Dafür müsste ich zuerst einen Index anlegen, der vom Typ int sein kann?



  • @Suprax
    Unter Berücksichtigung der Probleme, die SeppJ aufgezeigt hat, wäre es besser, wenn jede Person einen eindeutigen Schlüssel hätte, zB eine laufende Nummer.
    Diesen Schlüssel kann man dann im Bankkonto als Verweis auf die Person speichern.
    Wenn man jetzt auf die Person, die zu einem Konto gehört, zugreifen will, muss man alle Personen nach diesem Schlüssel durchsuchen.
    Wenn man so vorgeht, kann man den Personenvektor auch erweitern, oder Personen darin entfernen (entfernen natürlich nur, wenn sie nicht zu einem Konto gehören), ohne dass Probleme entstehen.

    Da bietet sich schon fast eine map <int, Person> an ...


  • Mod

    Ein Vector hat sowieso immer einen Index. Das ist sogar seine definierende Eigenschaft. Vergiss einfach alle Zeiger, speicher dir eine Zahl im Account, die auf eine Person in der Personenliste verweist.

    Ich stelle fest, dass dieses ganze Design und seine Probleme ziemlich ähnlich zu dem ist, was du das letzte Mal mit deiner Videothek hattest. Da hatte ich auch schon ein bisschen rumphilosophiert, dass das eigentlich nicht der Weisheit letzter Schluss sein kann. Siehe zum Beispiel Bellis naheliegende Verbesserung über meinem Beitrag.
    Kurz: Das ganze objektorientierte Design ist bei dir noch etwas holperig (aber sichtbar bemüht). Wie lernst du?



  • Hallo @Suprax,

    ich gebe dir (unabhängig von deinem Problem) noch einen Rat zum Naming.

    Und zwar hast du im Code:

    private:
        vector<Person> person;
        vector<Account> account;
    
    public:
        vector<Person> get_person() const;
        vector<Account> get_account() const;
    

    Du sprichst selbst auch vom "Vektor <Personen>". Schau dir mal an, was Singular und was Plural ist. Das mag jetzt vielleicht kleinlich erscheinen, erleichtert aber das Lesen des Codes.

    Dein vector<Person> person; sollte besser vector<Person> personen; (oder persons) heißen, dein vector<Account> account; sollte besser vector<Account> accounts; heißen.

    Analog dazu erwartet man, dass get_person() genau EINE Person zurückgibt, nicht einen Vektor. Das wäre eher get_persons() (ggf. wäre da die Rückgabe per const& sinnvoller).

    Das geht auch mit anderen Funktionen so weiter, print_person gibt nicht eine Person aus, sondern mehrere, sollte also print_persons heißen. Von der Frage, ob es wirklich zur Aufgabe einer Bank gehört, Personen anzulegen, Personen auszugeben etc., mal ganz abgesehen. Also noch ein Rat: tu nicht zu viel in eine Klasse rein!



  • @Belli sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    @Suprax
    Unter Berücksichtigung der Probleme, die SeppJ aufgezeigt hat, wäre es besser, wenn jede Person einen eindeutigen Schlüssel hätte, zB eine laufende Nummer.
    Diesen Schlüssel kann man dann im Bankkonto als Verweis auf die Person speichern.
    Wenn man jetzt auf die Person, die zu einem Konto gehört, zugreifen will, muss man alle Personen nach diesem Schlüssel durchsuchen.
    Wenn man so vorgeht, kann man den Personenvektor auch erweitern, oder Personen darin entfernen (entfernen natürlich nur, wenn sie nicht zu einem Konto gehören), ohne dass Probleme entstehen.

    Da bietet sich schon fast eine map <int, Person> an ...

    Ich schau mir mal die ``` map ````-Funktion an, gearbeitet habe ich noch nicht damit.

    @SeppJ sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    Ein Vector hat sowieso immer einen Index. Das ist sogar seine definierende Eigenschaft. Vergiss einfach alle Zeiger, speicher dir eine Zahl im Account, die auf eine Person in der Personenliste verweist.

    Ich stelle fest, dass dieses ganze Design und seine Probleme ziemlich ähnlich zu dem ist, was du das letzte Mal mit deiner Videothek hattest. Da hatte ich auch schon ein bisschen rumphilosophiert, dass das eigentlich nicht der Weisheit letzter Schluss sein kann. Siehe zum Beispiel Bellis naheliegende Verbesserung über meinem Beitrag.
    Kurz: Das ganze objektorientierte Design ist bei dir noch etwas holperig (aber sichtbar bemüht). Wie lernst du?

    Ja, ich stehe noch relativ am Anfang, bzw. im ersten Semester und muss mir das einverleihen. Ich lerne mit Bjarne Stroustrup "Einführung in die Programmierung mit C++" und mit Kommilitonen, die mir ab und an helfen.
    Ich versuch mich da ranzuhalten, es macht mir ja auch Spaß Erfolge zu feiern. Nur dann gibts halt solche Momente, wo ich noch einfach nicht selber voran komme.

    Bzgl. der Zahl, die ich speichern soll: Ich arbeite ja mit Altklausuren und da habe ich meine Vorgaben bzgl. der Parameter und Methoden. Ganz Freihand habe ich da nicht und dein Vorschlag mit dem Speichern einer Zahl, die auf eine Person verweist, muss dem Konstruktor mitgegeben werden...wenn ich mich nicht irre. Die Vorgaben des Konstruktors dürfte ich z.b. nicht ändern.

    @wob Ja, mache ich. In Zukunft setze ich das so um.



  • Die Signatur des Konstruktors selbst müsstest Du ja gar nicht ändern.
    Wenn die Person einen Schlüssel hat, nimmst Du den im Account-Konstruktor aus der übergebenen Person und speicherst ihn ...
    Aber vielleicht ist Dir das alles noch zu kompliziert ...
    Ich habe sowieso das Gefühl, dass Du zu viel für Deinen Kenntnisstand willst?

    Edit:
    Noch besser wäre es vom Design, wenn Dein Account gar nicht wüsste, dass es Personen gibt.
    Wenn sowohl jede Person als auch jeder Account einen eindeutigen Schlüssel hat, kann man eine weitere Datenstruktur einführen, die die beiden zusammenbringt, dann hättest Du ein Datenbankähnliches Design, das sehr flexibel ist, zB könnte dann eine Person ganz easy mehrere Konten haben ...
    Person
    {
    int schluessel;
    weitere Personendaten ...
    }
    Account
    {
    int schluessel;
    string Kontonr;
    evtl. weitere Kontodaten ...
    }

    Kontoinhaber
    {
    int Personenschluessel;
    int Accountschluessel;
    }

    vector<Person> ...
    vector<Account> ...
    vector<Kontoinhaber> ...



  • @Belli das vermute ich auch. Ich muss Step-by-Step mir das erarbeiten, aber das habe ich ja am Anfang meines Threads erwähnt. Ich möchte diesen Code so simple wie möglich halten. In der Klausur ist dieser Stil des Codes schon vom Niveau her gut genug, dass ich damit mit sehr guter Note durchkomme. Fehlt nur noch die Logik gewisse Methoden auch umgesetzt zu bekommen.
    Ich denke das Niveau sehr gut zu coden kommt im Laufe des Studiums - natürlich mit viel Zeitaufwand, Geduld und Übung.



  • Nach meiner Logik her, würde ich Personen und Accounts in getrennten Klasse verwalten. Das eine hat mit dem anderen ja prinzipiell nichts zu tun bzw. Funktionen der Account-Klasse ändern nie Personendaten, sondern fragen sie höchstens ab.

    D.h. ich würde ich eine Klasse für die Personen machen, mit den notwendigen Funktionen ( erzeugen, löschen, abfragen ):

    class Personenverwaltung
    {
    public:
        Personenverwaltung();
        ~Personenverwaltung();
    
       void createPerson( const std::string &vorname, const std::string &nachname );
       void removePerson( const std::string &vorname, const std::string &nachname );
       bool personBekanntName( const std::string &vorname, const std::string &nachname ) const;
       bool personBekanntId( unsigned personenid ) const;
       // ..... etc.
    };
    

    Und dann eine Klasse Kontenverwaltung

    class Kontenverwaltung
    {
    public:
        Kontenverwaltung( const Personenverwaltung & );
        ~Kontenverwaltung();
        
        void createAccount( const std::string &vorname, const std::string &nachname );
        void removeAccount( const std::string &vorname, const std::string &nachname );
    };
    

    Die Kontenverwaltung kennt somit alle Personen, kann aber lediglich Informationen zu den Personen abfragen und nichts ändern. Somit sind die eigentlichen Banking-Funktionalitäten sauber getrennt von den Personendaten.

    Nur als genereller Vorschlag von mir.



  • Und noch ein anderer genereller Fehler ist in der Programm-Logik:

    void Bank::menu() {
    
        Bank bank1;
    

    Um diese Funktion aufzurufen, mußt du doch schon ein Bank-Objekt anlegen, erzeugst dann aber ein weiteres lokales Bank-Objekt bank1, für das du die weiteren Funktionen aufrufst, so daß nach Verlassen dieser menu-Funktion alle Daten verworfen sind!
    Die menu-Funktion gehört auch nicht in die Bank-Klasse, sondern sollte eigenständig sein (Klassen der Logik-Schicht sollten keine direkte Ein- oder Ausgabe besitzen).



  • @Th69 sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    Und noch ein anderer genereller Fehler ist in der Programm-Logik:

    void Bank::menu() {
    
        Bank bank1;
    

    Um diese Funktion aufzurufen, mußt du doch schon ein Bank-Objekt anlegen, erzeugst dann aber ein weiteres lokales Bank-Objekt bank1, für das du die weiteren Funktionen aufrufst, so daß nach Verlassen dieser menu-Funktion alle Daten verworfen sind!
    Die menu-Funktion gehört auch nicht in die Bank-Klasse, sondern sollte eigenständig sein (Klassen der Logik-Schicht sollten keine direkte Ein- oder Ausgabe besitzen).

    Nein, die menu-Funktion soll in der Klasse drinne sein. Das ist vorgegeben.
    Das Bank-Objekt lege ich mit Beginn der menu-Funktion an, damit dort im Prozess der Benutzereingabe sämtliche Daten dort gespeichert werden.

    @It0101 sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    Nach meiner Logik her, würde ich Personen und Accounts in getrennten Klasse verwalten. Das eine hat mit dem anderen ja prinzipiell nichts zu tun bzw. Funktionen der Account-Klasse ändern nie Personendaten, sondern fragen sie höchstens ab.

    D.h. ich würde ich eine Klasse für die Personen machen, mit den notwendigen Funktionen ( erzeugen, löschen, abfragen ):

    class Personenverwaltung
    {
    public:
        Personenverwaltung();
        ~Personenverwaltung();
    
       void createPerson( const std::string &vorname, const std::string &nachname );
       void removePerson( const std::string &vorname, const std::string &nachname );
       bool personBekanntName( const std::string &vorname, const std::string &nachname ) const;
       bool personBekanntId( unsigned personenid ) const;
       // ..... etc.
    };
    

    Und dann eine Klasse Kontenverwaltung

    class Kontenverwaltung
    {
    public:
        Kontenverwaltung( const Personenverwaltung & );
        ~Kontenverwaltung();
        
        void createAccount( const std::string &vorname, const std::string &nachname );
        void removeAccount( const std::string &vorname, const std::string &nachname );
    };
    

    Die Kontenverwaltung kennt somit alle Personen, kann aber lediglich Informationen zu den Personen abfragen und nichts ändern. Somit sind die eigentlichen Banking-Funktionalitäten sauber getrennt von den Personendaten.

    Nur als genereller Vorschlag von mir.

    Personen, Accounts und Bank sind in jeweils getrennten Klassen


  • Mod

    @Suprax sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    Nein, die menu-Funktion soll in der Klasse drinne sein. Das ist vorgegeben.

    Das ist trotzdem schlechtes Design und es sollte dein Bestreben sein, es korrekt zu machen. Die Klassen sollten der Wirklichkeit folgen, sonst bekommst du später komische Effekte (Oder auch jetzt sofort, denn dein Fragen sind Folgen von mittelmäßigem Design). Echte Banken haben Menüs höchsten in der Kantine. Banken haben auch keine Computerschnittstelle zum Bedienen einer Bankingsimulation. Banken haben keine Personen, sondern ein Personenverzeichnis. Wer aber Personen und Banken und eine Computerschnittstelle zur Bankingsimulation hat, wäre beispielsweise ein Bankingsimulator. Das sollte eine Klasse bei dir sein, in deren Instanzen dann Banken und Personen existieren, deren Zusammenspiel über die Schnittstelle gesteuert wird.

    Das Bank-Objekt lege ich mit Beginn der menu-Funktion an, damit dort im Prozess der Benutzereingabe sämtliche Daten dort gespeichert werden.

    Du hast das Problem gar nicht verstanden. Die menu-Funktion ist bei dir schon Teil einer Bank. Du hast ein Bank in deiner Bank erzeugt.



  • Ich bin mittlerweile voran gekommen und fast fertig.
    Allerdings muss ich jetzt die Buchungen, die der Benutzer tätigen kann, zeitlich ordnen.
    Die Zeitangabe, wann die Buchungen statt finden, entscheidet der Benutzer selbst.
    Habt ihr eine Idee wie ich die am besten sortiert bekomme?

    @SeppJ sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    @Suprax sagte in *Bankkonto*: Verweis auf ein Objekt anderer Klasse richtig übergeben? Keine Ausgabe!:

    Nein, die menu-Funktion soll in der Klasse drinne sein. Das ist vorgegeben.

    Das ist trotzdem schlechtes Design und es sollte dein Bestreben sein, es korrekt zu machen. Die Klassen sollten der Wirklichkeit folgen, sonst bekommst du später komische Effekte (Oder auch jetzt sofort, denn dein Fragen sind Folgen von mittelmäßigem Design). Echte Banken haben Menüs höchsten in der Kantine. Banken haben auch keine Computerschnittstelle zum Bedienen einer Bankingsimulation. Banken haben keine Personen, sondern ein Personenverzeichnis. Wer aber Personen und Banken und eine Computerschnittstelle zur Bankingsimulation hat, wäre beispielsweise ein Bankingsimulator. Das sollte eine Klasse bei dir sein, in deren Instanzen dann Banken und Personen existieren, deren Zusammenspiel über die Schnittstelle gesteuert wird.

    Das Bank-Objekt lege ich mit Beginn der menu-Funktion an, damit dort im Prozess der Benutzereingabe sämtliche Daten dort gespeichert werden.

    Du hast das Problem gar nicht verstanden. Die menu-Funktion ist bei dir schon Teil einer Bank. Du hast ein Bank in deiner Bank erzeugt.

    @SeppJ Ich kann da leider bzgl. der menu-Funktion nichts machen. Sie muss so implementiert werden, wie es vorgegeben wurde. Ich bin nicht der Prof 😃

    Du hast das Problem gar nicht verstanden. Die menu-Funktion ist bei dir schon Teil einer Bank. Du hast ein Bank in deiner Bank erzeugt.

    Hmm. Indem ich zusätzlich ein Objekt der Klasse Bank in der Klasse Bank erzeugt habe, habe ich eine Bank in meiner Bank erzeugt?


Anmelden zum Antworten