Array von Strukturen



  • Hi Leute,

    ich muss für die Uni bis nächste Woche ein kleines Programm programmieren und komme nicht so recht weiter.

    So sieht mein Code bisher aus:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define KONTOANZ 99
    
    struct konto{
           unsigned int   kontoNr;              /* Kontonummer */
           float          kontoStnd;            /* Kontostand */
           float          zinsS;                /* Zinssatz */
           float          annuitaet;            /* Annuität */
           char           habenOderDarl;        /* Guthaben/Darlehen */
           unsigned int   laufZt;               /* Laufzeit */ 
    };
    
    struct konto k[KONTOANZ];                   /* Array mit der Größe xx */
    struct konto *kk = k;                       /* Zeiger auf Array k */
    
    void eingabe();                             /* Methode um Array mit Konten zu 
                                                   füllen */
    void ausgabe();                             /* Methode um Konto im Array wieder 
                                                   auszugeben */
    

    Es geht mir um die void eingabe()-Funktion. Ich soll die mit einer Schleife programmieren und es soll in der Methode gefragt werden wieviele Konten erstellt werden sollen. Die ganzen Daten sollen dann mit Zeigern an den struct konto k[] übergeben werden. Meine Fragen sind:

    1. Welche Schleife eignet sich für sowas am besten? (ich vermute die for-Schleife)

    2. Kann ich den int-Wert mit dem Anzahl der Konten aus der Funktion mit einem Zeiger auf den Array verweisen? Mir ist bekannt, dass die Anzahl der Felder vor dem Ausführen des Programms festgelegt sein muss, aber fast jede Regel hat eine Ausnahme. 😃

    Es wäre nett, wenn ihr mir einen Ansatz für die eingabe-Funktion geben könntet. Ich hab versucht es zu googlen, aber ohne großen Erfolg. Vielen Dank schonmal in Voraus!



  • 1. for-Schleife würde ich auch verwenden, auch wenn theoretisch jede Schleife genutzt werden könnte.

    2. Bei einem statisch angelegten Arraz kannst du die Größe nicht ändern. Möglich wären VLA's (variable length array), die sollten aber lokal in einer Funktion sein, oder du holst dir den Speicher per malloc()/free().

    3. Wie würdest du denn einen Konto-Datensatz einlesen? Das mußt du jetzt nur noch in eine Schleife packen:

    for(int i = 0; i<anzahl; ++i)
    {
      printf("Kontodaten für das %i. Konto:\nKontonummer:\n")
      scanf("%u",&k[i].kontoNr);
      //...
    }
    


  • Zunächst einmal solltest du statt float gleich double nehmen. Alle internen Berechnungen werden eh in double gemacht und die Speicherersparniss spielt heute keine Rolle mehr.

    Dann sollten Geldbeträge immer in Cent als Ganzzahl (int) berechnet werden, damit du keine Rundungsfehler bekommst.

    1. Ja, obwohl das eigentlich keine Rolle spielt.
    Bei for und while (sind eh äquivalent) wird vorher die Abbruchbedingung geprüft bevor die Schleife ausgeführt wird.
    Bei do-while wird die Schleife mindestens einmal durchlaufen und dann geprüft.

    2. Bei C99 kannst du Array mit Variabler Größe anlegen.
    Oder du besorgst dir den Speicher über malloc().

    int eingabe(struct konto k[], int max_anz)
    { int anz, i;
      anz einlesen
    
      prüfen ob anz gültig
    
      anz mal 
      {  kontonr einlesen
        ...
        laufZt einlesen
      }
    
      return anz;
    }
    

    Na gut, jetzt hat CStoll die fragen auch schon beantwortet.



  • Vielen Dank euch beiden! 🙂 Hab garnicht so schnell mit Antworten gerechnet. Da hab ich mich wohl in einem super Forum angemeldet. 😉 Ich hoffe ich kann irgendwann auch etwas beitragen und anderen helfen. Aber bis dahin viel zu lernen ich noch hab, wie Meister Yoda sagen würde. 😃

    Ich werd es gleich mal ausprobieren. Ihr habt mir schonmal um einiges weitergeholfen. 👍



  • typedef struct {
           unsigned int   kontoNr;              /* Kontonummer */
           float          kontoStnd;            /* Kontostand */
           float          zinsS;                /* Zinssatz */
           float          annuitaet;            /* Annuität */
           int           habenOderDarl;        /* Guthaben/Darlehen */
           unsigned int   laufZt;               /* Laufzeit */
    } Konto;
    
    void eingabe(Konto *konto)
    {
      printf("\nNr: ");scanf("%u",&konto->kontoNr);
      ... usw.
    }
    
    void ausgabe(const Konto *konto)
    {
      printf("\nNr: %u",konto->kontoNr);
      ... usw.
    }
    
    int main()
    {
      Konto konten[KONTOANZ];                   /* Array mit der Größe xx */
      int i;
      for(i=0;i<KONTOANZ;++i)
      {
        printf("\n Geben Sie jetzt Daten ein zum %d. Konto\n",i+1);
        eingabe( &konten[i] );
      }
      for(i=0;i<KONTOANZ;++i)
      {
        printf("\n Ausgabe zum %d. Konto\n",i+1);
        ausgabe( &konten[i] );
      }
      return 0;
    }
    

    Fehlerbehandlung und vorzeitiger Abbruch der Konteneingabe ist noch nötig, aber du willst ja sicher auch noch selber was machen.



  • Wutz schrieb:

    typedef struct {
           unsigned int   kontoNr;              /* Kontonummer */
           float          kontoStnd;            /* Kontostand */
           float          zinsS;                /* Zinssatz */
           float          annuitaet;            /* Annuität */
           int           habenOderDarl;        /* Guthaben/Darlehen */
           unsigned int   laufZt;               /* Laufzeit */
    } Konto;
    
    Konto konten[KONTOANZ];                   /* Array mit der Größe xx */
    
    void eingabe(Konto *konto)
    {
      printf("\nNr: ");scanf("%f",&konto->kontoNr);
      ... usw.
    }
    
    void ausgabe(const Konto *konto)
    {
      printf("\nNr: %d",konto->kontoNr);
      ... usw.
    }
    
    int main()
    {
      int i;
      for(i=0;i<KONTOANZ;++i)
      {
        printf("\n Geben Sie jetzt Daten ein zum %d. Konto\n",i+1);
        eingabe( &konten[i] );
      }
      for(i=0;i<KONTOANZ;++i)
      {
        printf("\n Ausgabe zum %d. Konto\n",i+1);
        ausgabe( &konten[i] );
      }
      return 0;
    }
    

    Fehlerbehandlung und vorzeitiger Abbruch der Konteneingabe ist noch nötig, aber du willst ja sicher auch noch selber was machen.

    Vielen Dank! Ich kann garnicht genug danken. Ich sass hier schon seit einiger Zeit und hab rumprobiert, aber es nicht hinbekommen - und für euch scheint es wohl total simple zu sein. Naja, ich bin noch ein absoluter Newbie in C und unser Prof. bringt es uns leider nicht wirklich gut bei.

    Ein Teil von den angesprochenen Sachen hab ich auch schon:

    do {
           printf("-1- Neues Konto anlegen\n");
           printf("-2- Alle Kontodaten ausgeben\n");
           printf("-3- Programm beenden\n");
           printf("\nIhre Auswahl : ");
           scanf("%d", &auswahl);
    
           getchar();
           switch(auswahl) {
              case 1 : eingabe();
                       break;
              case 2 : ausgabe();
                       break;
              case 3 : printf("Programm beendet\n");
                       break;
              default: printf("Falsche Eingabe\n");
           }
        }while(auswahl <3);
    


  • Wenn es dir zu kompliziert ist, solltest du das Problem in kleinere Häppchen zerlegen.
    - Wie kannst du einen Konto-Datensatz einlesen bzw. ausgeben? Da habe wir dir schon den Lösungsansatz gezeigt, du mußt nur die übrigen Elemente ergänzen.
    - Wie erreichst du alle vorhandenen Konto-Sätze? Eine Schleife
    (wenn ich die Ausgaben deines Programms richtig deute, soll die Funktion eingabe() jeweils einen Datensatz einlesen - dafür mußt du dir auch merken, wieviele Einträge du bereits hast):

    Konto konten[KONTOANZ];
    unsigned kontonzahl = 0;
    
    void eingabe()
    {
      if(kontenzahl==KONTOANZ)
      {
        printf("kein Platz für weitere Konten\n");
        return;
      }
      //alle Werte einlesen in konten[kontenzahl]
      ++kontenzahl;
    }
    
    void ausgabe()
    {
      for(unsigned i=0;i<kontenzahl;++i)
      {
        //Inhalte von konten[i] ausgeben
      }
      if(kontenzahl==0)
      {
        printf("keine Konten angelegt\n");
      }
    }
    


  • Vielen Dank nochmal! Ihr seit echt super! Ich finds richtig nett, dass ihr mir helft. Ich war heute ganzen Tag unterwegs und kam noch nicht dazu alle eure Tipps umzusetzen. Ich mach mich gleich an die Arbeit und melde mich dann später wieder, falls ich irgendwo nicht weiterkomme. Am Ende poste ich aufjedenfall den fertigen Code. 🙂



  • So sieht mein Code jetzt aus:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define DARLEHENSZINS 0.05
    #define GUTHABENSZINS 0.03
    #define KONTOANZ 10
    #define BANKNR
    
    typedef struct {
           unsigned int   kontoNr;              /* Kontonummer */
           double         kontoStnd;            /* Kontostand */
           double         zinsS;                /* Zinssatz */
           double         annuitaet;            /* Annuität */
           char           habenOderDarl;        /* Guthaben/Darlehen */
           unsigned int   laufZt;               /* Laufzeit */ 
    } Konto;
    
    struct Konto konten[KONTOANZ];              /* Array mit der Größe xx */
    struct Konto *kk = konten;
    
    void eingabe();                             /* Methode um Array mit Konten zu 
                                                   füllen */
    void ausgabe();                             /* Methode um Konto im Array wieder 
                                                   auszugeben */
    
    double kapZins(float kontoStnd, int laufZt);
    
    double darZins(float kontoStnd, int annuitaet);
    
    int main(int argc, char *argv[])
    {
        int i;
        int auswahl;                            /* Speicherung für die Bedingung */
    
        printf("\n\t Zweites Programm in SS11, Strukturen");
        printf("\ von xx");
        printf("\n\t uebersetzt am %s", __DATE__);
        printf("\n\t um %s Uhr", __TIME__);
        printf("\n\n");
    
        do {
           printf("-1- Neues Konto anlegen\n");
           printf("-2- Alle Kontodaten ausgeben\n");
           printf("-3- Programm beenden\n");
           printf("\nIhre Auswahl : ");
           scanf("%d", &auswahl);
    
           getchar();
           switch(auswahl) {
              case 1 : eingabe();
                       break;
              case 2 : ausgabe();
                       break;
              case 3 : printf("Programm beendet\n");
                       break;
              default: printf("Falsche Eingabe\n");
           }
        }while(auswahl <3);
    
        system("PAUSE");	
        return 0;
    }
    
    void eingabe(Konto *konten){
    
         int anz, i;
    
         prinft("Wieviele Konten sollen erstellt werden?");  scanf("%i", &anz);
    
         if(anz == 0)
         {
                   prinft("Diese Anzahl ist ungueltig\n");
         }
    
         for(i = 0; i<anz; ++i)
         {
                   printf("Kontodaten für das %i. Konto eingeben: ", i);
                   printf("Kontostand: ");     scanf("%d", &konten->kontoStnd);
         }
    }
    

    Es tritt leider dieser Fehler auf: storage size of 'konten' isn't known

    Es ist mir klar, dass es wohl an meinem Array bzw. mit den Zeigern auf Array zusammenhängt, aber ich komme nicht drauf wie ich es richtig machen soll. Hab schon einiges rumprobiert, aber komme einfach nicht auf die richtige Lösung.

    Die Ausgabe-Funktion soll übrigens das Darlehen bzw. Anlagekapital ausgeben.

    Ich habe mir überlegt, dass ich dazu in der eingabe-Funktion ein "g" oder ein "d" als char an die Variable habenOderDarl übergebe und die Ausgabe-Funktion dann so aussehen soll:

    void ausgabe(){
    
       if(konten->habenOderDarl == 'g')
       {
          double kapZins(float kontoStnd, int laufZt);
       }
       if(konten->habenOderDarl == 'd')
       {
          double darZins(float kontoStnd, int annuitaet);
       }
    }
    

    Das sollte funktionieren, oder?



  • Erstens: Wenn du die struct per typedef struct{...} Konto; anlegst, brauchst du bei den Variablen-Definitionen das "struct" nicht mehr zu verwenden.

    Zweitens: Du hast die Funktionen eingabe() und ausgabe() mit leerer Parameterliste (das ist afair die Prä-Ansi-Formulierung für "du brauchst nicht zu prüfen, welche Parameter kommen") deklariert und ohne Parameter aufgerufen - bei der Definition wird aber ein Parameter erwartet.

    Drittens:

    void ausgabe(){
    
       if(konten->habenOderDarl == 'g')
       {
          double kapZins(float kontoStnd, int laufZt);
       }
       if(konten->habenOderDarl == "d")
       {
          double darZins(float kontoStnd, int annuitaet);
       }
    }
    

    Das ist syntaktisch falsch - wenn überhaupt, willst du an dieser Stelle die Funktionen aufrufen (und ihre Rückgabe irgendwo speichern). Außerdem solltest du dir den Unterschied zwischen einem char- und einem String-Literal ansehen 😉

    Viertens: Bei der Eingabe solltest du auch sicherstellen, daß du nicht über das Array-Ende hinaus schreibst. Bei mehr als 10 Konten würdest du Daten zerstören, von deren Existenz du noch nicht einmal weißt.



  • Ein Haufen blöder Fehler also. 😃 Danke für die schnelle Antwort! Ich werde versuchen in meinem C-Programmierung Buch Lösungen darauf zu finden.



  • Ich sitze schon seit mehr als 2 Tagen an diesem Programm und kriege es einfach nicht hin so wie ich es möchte. 😞 Wahrscheinlich ist das was ich vorhabe einfach noch viel zu kompliziert für meine Programmierkenntnisse. Kann jemand eventuell die Aufgabenstellung durchlesen und mir sagen, ob mein bisherigen Ansatz vielleicht zu kompliziert ist oder irgendwo ein Denkfehler drin ist.

    Die genau Aufgabenstellung ist:

    Vereinbaren Sie eine Struktur mit Kontodaten! Sie soll enthalten: Kontonummer, Kontostand, ob es sich um ein Haben- oder Darlehenskonto handelt, Zinssatz und Annuität. Mehrere Strukturen dieser Art sind in einen Array zu fassen. Für alle Array-Elemente ist auszurechnen, wie der Tilgungs- oder Guthabens-Verlauf ist.

    Die Werte einiger der Struktur-Felder dürfen fest vorgegeben bzw. berechnet werden. Die Höhe des aufgenommenen Darlehens und die Annuität sind aber einzulesen; ebenso die Länge der Anlagedauer und die Höhe des angelegten Kapitals. Sowohl beim Einrichten der Konten, als auch bei den Berechnungen soll jeweils mit einer Schleife über alle Konten gearbeitet werden. Eine passende Gliederung in Unterprogramme ist wichtig. Keine Funktion, auch nicht die main()-Funktion soll mehr als 100 Zeilen haben.

    --------------------------

    Die eingabe()- und ausgabe()-Funktion bereiten mir Probleme. Die Anzahl der Konten soll bei der eingabe() abgefragt werden. Es ist mir aber immernoch nicht klar wie ich diese Anzahl an das Array übergeben soll und wie ich alle angelegten Konten bei der ausgabe()-Funktion ausgeben soll.



  • mr_unknown schrieb:

    Die eingabe()- und ausgabe()-Funktion bereiten mir Probleme. Die Anzahl der Konten soll bei der eingabe() abgefragt werden. Es ist mir aber immernoch nicht klar wie ich diese Anzahl an das Array übergeben soll und wie ich alle angelegten Konten bei der ausgabe()-Funktion ausgeben soll.

    1. Die Größe der Funktion ist nicht so wichtig. Wichtig ist eher, dass du jeder Funktion eine Aufgabe zuweist, die sich ständig wiederholt und die sich selbst sonst um gar nichts kümmert. Da kann eine Nachrichtenbehandlungsfunktion auch mal 5000 Zeilen lang werden.

    2. Kennst du die Funktion malloc ? Sie reserviert Speicher auf dem Heap, den du hinterher wieder freigeben musst.

    Aber in deinem Fall würde ich erstmal den Umgang mit Zeigern auf dem Stack lernen, bevor du an den für Anfänger wesentlich "gefährlicheren" Heap gehst. Lern das Zeiger- und Adressenkonzept auswendig, und dann verwende malloc .



  • Glühbirne schrieb:

    mr_unknown schrieb:

    Die eingabe()- und ausgabe()-Funktion bereiten mir Probleme. Die Anzahl der Konten soll bei der eingabe() abgefragt werden. Es ist mir aber immernoch nicht klar wie ich diese Anzahl an das Array übergeben soll und wie ich alle angelegten Konten bei der ausgabe()-Funktion ausgeben soll.

    1. Die Größe der Funktion ist nicht so wichtig. Wichtig ist eher, dass du jeder Funktion eine Aufgabe zuweist, die sich ständig wiederholt und die sich selbst sonst um gar nichts kümmert. Da kann eine Nachrichtenbehandlungsfunktion auch mal 5000 Zeilen lang werden.

    2. Kennst du die Funktion malloc ? Sie reserviert Speicher auf dem Heap, den du hinterher wieder freigeben musst.

    Aber in deinem Fall würde ich erstmal den Umgang mit Zeigern auf dem Stack lernen, bevor du an den für Anfänger wesentlich "gefährlicheren" Heap gehst. Lern das Zeiger- und Adressenkonzept auswendig, und dann verwende malloc .

    Ich habe Gestern über malloc in einem Buch gelesen und hab versucht es umzusetzen, aber ohne großen Erfolg. Ist es in diesem Fall die einzigste Möglichkeit? Wenn ja, dann muss ich mich länger damit auseinandersetzen, bis ich es hinkriege.



  • Die von mir gezeigte Lösung kommt komplett ohne malloc aus, d.h. natürlich nicht, dass du malloc nie brauchen wirst.



  • mr_unknown schrieb:

    Ich habe Gestern über malloc in einem Buch gelesen und hab versucht es umzusetzen, aber ohne großen Erfolg. Ist es in diesem Fall die einzigste Möglichkeit? Wenn ja, dann muss ich mich länger damit auseinandersetzen, bis ich es hinkriege.

    Sagen wir mal so, um Zeiger wirst du nicht herumkommen. Selbst wenn du die Plattformunabhängigkeit über Bord wirfst und HeapAlloc unter Windows verwendest, musst du immer noch wissen, was Zeiger und Adressen sind. Und auch mit C++ und dem new -operator kannst du ohne ein Dereferenzierungsobjekt nix anfangen. Viele Wege führen nach Rom, aber dafür musst du in der Lage sein, die Landkarte zu lesen.

    Im übrigen: 'einzigste' jüft üt nisch, det is de 'einzige'.



  • Das mit den Zeigern werde ich vielleicht noch hinkriegen, aber Heap würde mich wohl überfordern. Ich denke nicht, dass die das von einem Stundeten im 2. Semester erwarten. Eventuell muss ich einen Array mit einer variablen länge in die eingabe()-Funktion einbauen oder über malloc Speicher reservieren. Ich Frage mich nur was die einfachste Lösung ist. Das Programm soll nur gut genug sein, damit ich ein Testat bekomme, sonst werde ich am Ende des Semesters nicht zu der Klausur zugelassen werden. Nach 2 Vorlesungen C-Programmierung sind meine Kenntnisse leider noch ziemlich begrenzt. 😞



  • Die "einfachste" Lösung ist wohl, wenn du eine Obergrenze der Datensätze vorgibst (und ein Array in dieser Größe vorgibst). Zusätzlich legst du noch eine Variable an, die die Anzahl der tatsächlich genutzten Datensätze enthält*.
    Die nächste Variante wäre ein VLA in der main()-Funktion (da mußt du vor der Eingabe abfragen, wieviele Datensätze zu erwarten sind.
    Die dritte Variante ist malloc(), um einen entsprechend großen Speicherbereich zu reservieren.

    *das benötigst du in allen Varianten



  • Danke für all die Hilfe, CStoll! 👍 Hab nicht gedacht, dass mir dieses Programm solche Probleme bereiten wird. Ich werd´ versuchen mit einer von dir vorgeschlagenen Varianten bis zum Abend zum Erfolg zu kommen. Aufgeben ist für mich keine Option, da ich das Testat für diese Aufgabe unbedingt brauche. 🙂



  • Ich habe das Programm jetzt im groben fertig, aber es sind wohl noch Denkfehler drin, denn bei der ausgabe() kommt es zu einer Endlosschleife - leider. Könnt ihr mir sagen, ob ich den folgenden Code so korrigieren kann, dass es funktioniert? Oder ist mein Ansatz koplett unbrauchbar?

    Hier der Code:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define DARLEHENSZINS 0.05
    #define GUTHABENSZINS 0.03
    #define KONTOANZ 100
    #define BANKNR
    
    typedef struct {
           unsigned int   kontoNr;              /* Kontonummer */
           double         kontoStnd;            /* Kontostand */
           double         zinsS;                /* Zinssatz */
           double         annuitaet;            /* Annuität */
           char           habenOderDarl;        /* Guthaben/Darlehen */
           unsigned int   laufZt;               /* Laufzeit */ 
    } Konto;
    
    Konto konten[KONTOANZ];
    int anz;
    Konto *kk = konten;
    
    int eingabe();                             /* Methode um Array mit Konten zu 
                                                   füllen */
    int ausgabe();                             /* Methode um Konto im Array wieder 
                                                   auszugeben */
    
    double kapZinsS(double kontoStnd, unsigned int laufZt);
    
    double darZinsS(double kontoStnd, double annuitaet);
    
    int main(int argc, char *argv[])
    {
        int auswahl;                            /* Speicherung für die Bedingung */
    
        printf("\n\t Zweites Programm in SS11, Strukturen");
        printf(" von xx");
        printf("\n\t uebersetzt am %s", __DATE__);
        printf("\n\t um %s Uhr", __TIME__);
        printf("\n\n");
    
        do {
           printf("-1- Neues Konto anlegen\n");
           printf("-2- Alle Kontodaten ausgeben\n");
           printf("-3- Programm beenden\n");
           printf("\nIhre Auswahl : ");
           scanf("%d", &auswahl);
    
           getchar();
           switch(auswahl) {
              case 1 : eingabe();
                       break;
              case 2 : ausgabe();
                       break;
              case 3 : printf("Programm beendet\n");
                       break;
              default: printf("Falsche Eingabe\n");
           }
        }while(auswahl <3);
    
        system("PAUSE");	
        return 0;
    }
    
    int eingabe(int anz){
    
         int i;
    
         printf("Wieviele Konten sollen erstellt werden? ");  scanf("%i", &anz);
    
         for(i = 0; i<anz; ++i)
         {
               printf("Kontodaten fuer das %2i. Konto:\n", i+1);
               printf("Art des Kontos: ");    scanf("%2c", &konten[i].habenOderDarl);
               printf("Laufzeit: ");          scanf("%u", &konten[i].laufZt);
               printf("Guthaben/Darlehen: "); scanf("%d", &konten[i].kontoStnd);
         }
    
    }
    
    int ausgabe(const Konto *kk, int anz){
    
         int i;
    
         for(i = 0; i<anz; i++){
    
               if(kk->habenOderDarl == 'g')
               {
               kapZinsS(kk->kontoStnd, kk->laufZt);
               }
               if(kk->habenOderDarl == 'd')
               {
               darZinsS(kk->kontoStnd, kk->annuitaet);
               }
         }                 
    }
    
    /* Berechnung der Kapitalanlage mit Schleife */
    double kapZinsS(double kontoStnd, unsigned int laufZt)
    {
           unsigned i;
           double zins;
    
           for(i=1; i<=laufZt; i++){
                    zins = kontoStnd * GUTHABENSZINS;
                    kontoStnd = kontoStnd + zins;
                    printf("Jahr: %u\n", i);
                    printf("Anlaufende Zinsen: %.2d \n", zins);
                    printf("Kapital nach Zinsen: %.2d \n", kontoStnd);                
           }
           return kontoStnd;
    }
    
    /* Berechnung der Tilgung mit Schleife */
    double darZinsS(double kontoStnd, double annuitaet)
    {
           unsigned i;
           double zins;
           double tilgungsrate;
    
           for(i=i; i >= kontoStnd; i++){
                    zins = kontoStnd * DARLEHENSZINS;
                    tilgungsrate = annuitaet - zins;
                    kontoStnd = kontoStnd - tilgungsrate;
                    printf("Jahr: %u\n", i);
                    printf("Zinsen: %.2d \n", zins);
                    printf("Restschuld: %.2d \n", kontoStnd);
           }
           return kontoStnd;
    }
    

    Ich weiß nicht, ob es möglich ist auf die schnelle Fehler in so einem Code zu finden, ohne es im Compiler ablaufen zu lassen, aber ich denke für gute Programmierer stellt es kein großes Problem dar. Ich wäre euch sehr sehr dankbar!


Log in to reply