call by reference fkt in class < C/C++ < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 19:02 Di 08.01.2013 | | Autor: | pina7 |
| Aufgabe | Ein Kredit wird in festen (konstanten) monatlichen Raten zurückgezahlt. Schreiben Sie ein Programm, das die Kreditsumme (Kapital), den (jährlichen) Zinssatz und die monatliche Zahlung (Rate = Zinsen + Tilgung) einliest, daraus Restschuld, Zinsen und Tilgung am Ende jedes Monat berechnet und diese Daten jeweils in einer Zeile als tabellarische Übersicht hinter einer Monats-Nr. ausgibt, bis der Kredit vollständig zurückgezahlt ist.
Der Kredit soll in einer Klasse verwaltet werden. Überlegen Sie sich, welche Informationen die Klasse benötigt. Die Klasse soll über eine Funktion „getCredit“ verfügen, die die monatliche Tilgung als Parameter entgegennimmt. Außerdem sollen die Restschuld, die Zinsen, sowie die Tilgung an den Aufrufer zurückgegeben werden. Sehen Sie sich dazu das Kapitel „Call by Reference“ im Skript an. Die Funktion selbst soll vom Typ bool sein und so lange „false“ zurückgeben, bis die Restschuld auf 0 gesunken ist.
Hinweise: Es gilt: Monatszinsen = Kapital * Jahreszinssatz/100/12. Außerdem ist zu beachten, dass die letzte Rate ein Sonderfall ist, da die Rate die Restschuld nicht übersteigen sollte.
Beispiel: Kapital = 50.000 €, Zinssatz = 4% pro Jahr, Monatsrate = 300 €, Ausgabe:
Monat Restschuld [Euro] Zinsen [Euro] Tilgung[Euro]
1 49866.67 166.67 133.33
2 49732.89 166.22 133.78
... ... ... ...
244 204.72 1.68 298.32
245 0.00 0.68 204.72 |
Hallo. Bei dieser Aufgabe benötige ich bitte Hilfe bzgl. der bool Funktion. Bisher liefert mir mein Programm nur die erste Zeile und hierbei ist auch die Restschuld nicht richtig. Ebenso habe ich noch keine gute Möglichkeit zum Formatieren der Tabelle (Zeilenabstand) gefunden. Dankeschön
| 1: |
| | 2: | #pragma once
| | 3: | #include "stdafx.h"
| | 4: |
| | 5: | class Credit
| | 6: | {
| | 7: | protected:
| | 8: | float m_Kapital;
| | 9: | float m_Zinssatz;
| | 10: | float m_Rate;
| | 11: |
| | 12: | public:
| | 13: | float Kapital;
| | 14: | float Zinssatz;
| | 15: | float Rate;
| | 16: |
| | 17: | float Restschuld; // Restschuld = Kapital-Rate
| | 18: | float Zinsen; //Zinsen = Rate-Tilgung;
| | 19: | float Tilgung; //Tilgung = Rate-Zinsen;
| | 20: | int Monat;
| | 21: |
| | 22: | void setValues(float Kapital, float Zinssatz, float Rate);
| | 23: |
| | 24: | bool getCredit();
| | 25: | };
| | 26: |
| | 27: |
| | 28: | #include "stdafx.h"
| | 29: | #include <iostream>
| | 30: | #include "Credit.h"
| | 31: | #include <iomanip>
| | 32: |
| | 33: | using namespace std;
| | 34: |
| | 35: | void Credit::setValues(float Kapital, float Zinssatz, float Rate)
| | 36: | {
| | 37: | m_Kapital = Kapital;
| | 38: | m_Zinssatz = Zinssatz;
| | 39: | m_Rate = Rate;
| | 40: | }
| | 41: |
| | 42: | bool Credit::getCredit()
| | 43: | {
| | 44: | Restschuld = Kapital-Rate;
| | 45: | Monat = 0;
| | 46: |
| | 47: | if (Restschuld > 0)
| | 48: | {
| | 49: | float neueRestschuld = Restschuld;
| | 50: | Zinsen = Kapital*Zinssatz/100/12;
| | 51: | Tilgung = Rate-Zinsen;
| | 52: | neueRestschuld = Kapital-Rate;
| | 53: |
| | 54: | cout << setw(10) << Monat << fixed << setprecision(2) << " " << Restschuld << " " << fixed << setprecision(2) << " " << Zinsen << " " << fixed << setprecision(2) << " " << Tilgung << " " << endl << endl;
| | 55: |
| | 56: | Monat ++;
| | 57: |
| | 58: | return false;
| | 59: | }
| | 60: |
| | 61: | else if (Restschuld == 0)
| | 62: | {
| | 63: | return true;
| | 64: | }
| | 65: | }
| | 66: |
| | 67: | int _tmain(int argc, _TCHAR* argv[])
| | 68: | {
| | 69: | Credit MyCredit;
| | 70: |
| | 71: | cout << "Kreditrueckzahlung" << endl << endl;
| | 72: | cout << "Bitte Kapital eingeben: " << endl << endl;
| | 73: | cin >> MyCredit.Kapital;
| | 74: | cout << "Bitte Zinssatz eingeben: " << endl << endl;
| | 75: | cin >> MyCredit.Zinssatz;
| | 76: | cout << "Bitte Rate eingeben: " << endl << endl;
| | 77: | cin >> MyCredit.Rate;
| | 78: |
| | 79: | MyCredit.setValues(MyCredit.Kapital,MyCredit.Zinssatz,MyCredit.Rate);
| | 80: |
| | 81: | cout << setw(10) << "Monat " << " Restschuld [Euro] " << " Zinsen [Euro] " << " Tilgung [Euro] " << endl << endl;
| | 82: |
| | 83: | MyCredit.getCredit();
| | 84: |
| | 85: | system("pause");
| | 86: | return 0;
| | 87: | }
|
|
|
| |
|
Hallo pina7,
> Ein Kredit wird in festen (konstanten) monatlichen Raten
> zurückgezahlt. Schreiben Sie ein Programm, das die
> Kreditsumme (Kapital), den (jährlichen) Zinssatz und die
> monatliche Zahlung (Rate = Zinsen + Tilgung) einliest,
> daraus Restschuld, Zinsen und Tilgung am Ende jedes Monat
> berechnet und diese Daten jeweils in einer Zeile als
> tabellarische Übersicht hinter einer Monats-Nr. ausgibt,
> bis der Kredit vollständig zurückgezahlt ist.
> Der Kredit soll in einer Klasse verwaltet werden.
> Überlegen Sie sich, welche Informationen die Klasse
> benötigt. Die Klasse soll über eine Funktion
> „getCredit“ verfügen, die die monatliche Tilgung als
> Parameter entgegennimmt. Außerdem sollen die Restschuld,
> die Zinsen, sowie die Tilgung an den Aufrufer
> zurückgegeben werden. Sehen Sie sich dazu das Kapitel
> „Call by Reference“ im Skript an. Die Funktion selbst
> soll vom Typ bool sein und so lange „false“
> zurückgeben, bis die Restschuld auf 0 gesunken ist.
> Hinweise: Es gilt: Monatszinsen = Kapital *
> Jahreszinssatz/100/12. Außerdem ist zu beachten, dass die
> letzte Rate ein Sonderfall ist, da die Rate die Restschuld
> nicht übersteigen sollte.
> Beispiel: Kapital = 50.000 €, Zinssatz = 4% pro Jahr,
> Monatsrate = 300 €, Ausgabe:
> Monat Restschuld [Euro] Zinsen [Euro]
> Tilgung[Euro]
> 1 49866.67 166.67
> 133.33
> 2 49732.89 166.22
> 133.78
> ... ... ...
> ...
> 244 204.72 1.68
> 298.32
> 245 0.00 0.68
> 204.72
> Hallo. Bei dieser Aufgabe benötige ich bitte Hilfe bzgl.
> der bool Funktion. Bisher liefert mir mein Programm nur die
> erste Zeile und hierbei ist auch die Restschuld nicht
> richtig. Ebenso habe ich noch keine gute Möglichkeit zum
> Formatieren der Tabelle (Zeilenabstand) gefunden.
> Dankeschön
> | 1: |
| | 2: | > #pragma once
| | 3: | > #include "stdafx.h"
| | 4: | >
| | 5: | > class Credit
| | 6: | > {
| | 7: | > protected:
| | 8: | > float m_Kapital;
| | 9: | > float m_Zinssatz;
| | 10: | > float m_Rate;
| | 11: | >
| | 12: | > public:
| | 13: | > float Kapital;
| | 14: | > float Zinssatz;
| | 15: | > float Rate;
| | 16: | >
| | 17: | > float Restschuld; // Restschuld = Kapital-Rate
| | 18: | > float Zinsen; //Zinsen = Rate-Tilgung;
| | 19: | > float Tilgung; //Tilgung = Rate-Zinsen;
| | 20: | > int Monat;
| | 21: | >
| | 22: | > void setValues(float Kapital, float Zinssatz, float
| | 23: | > Rate);
| | 24: | >
| | 25: | > bool getCredit();
| | 26: | > };
| | 27: | >
| | 28: | >
| | 29: | > #include "stdafx.h"
| | 30: | > #include <iostream>
| | 31: | > #include "Credit.h"
| | 32: | > #include <iomanip>
| | 33: | >
| | 34: | > using namespace std;
| | 35: | >
| | 36: | > void Credit::setValues(float Kapital, float Zinssatz, float
| | 37: | > Rate)
| | 38: | > {
| | 39: | > m_Kapital = Kapital;
| | 40: | > m_Zinssatz = Zinssatz;
| | 41: | > m_Rate = Rate;
| | 42: | > }
| | 43: | >
| | 44: | > bool Credit::getCredit()
| | 45: | > {
| | 46: | > Restschuld = Kapital-Rate;
| | 47: | > Monat = 0;
| | 48: | >
| | 49: | > if (Restschuld > 0)
| | 50: | > {
| | 51: | > float neueRestschuld = Restschuld;
| | 52: | > Zinsen = Kapital*Zinssatz/100/12;
| | 53: | > Tilgung = Rate-Zinsen;
| | 54: | > neueRestschuld = Kapital-Rate;
| | 55: | >
| | 56: | > cout << setw(10) << Monat << fixed << setprecision(2) <<
| | 57: | > " " << Restschuld << " " << fixed <<
| | 58: | > setprecision(2) << " " << Zinsen << " " << fixed <<
| | 59: | > setprecision(2) << " " << Tilgung << " " << endl
| | 60: | > << endl;
| | 61: | >
| | 62: | > Monat ++;
| | 63: | >
| | 64: | > return false;
| | 65: | > }
| | 66: | >
| | 67: | > else if (Restschuld == 0)
| | 68: | > {
| | 69: | > return true;
| | 70: | > }
| | 71: | > }
| | 72: | >
| | 73: | > int _tmain(int argc, _TCHAR* argv[])
| | 74: | > {
| | 75: | > Credit MyCredit;
| | 76: | >
| | 77: | > cout << "Kreditrueckzahlung" << endl << endl;
| | 78: | > cout << "Bitte Kapital eingeben: " << endl << endl;
| | 79: | > cin >> MyCredit.Kapital;
| | 80: | > cout << "Bitte Zinssatz eingeben: " << endl << endl;
| | 81: | > cin >> MyCredit.Zinssatz;
| | 82: | > cout << "Bitte Rate eingeben: " << endl << endl;
| | 83: | > cin >> MyCredit.Rate;
| | 84: | >
| | 85: | > MyCredit.setValues(MyCredit.Kapital,MyCredit.Zinssatz,MyCredit.Rate);
| | 86: | >
| | 87: | > cout << setw(10) << "Monat " << " Restschuld [Euro]
| | 88: | > " << " Zinsen [Euro] " << " Tilgung [Euro] " <<
| | 89: | > endl << endl;
| | 90: | >
| | 91: | > MyCredit.getCredit();
| | 92: | >
| | 93: | > system("pause");
| | 94: | > return 0;
| | 95: | > }
| | 96: | > |
Die Funktionen setValues und getCredit sind etwas abzuändern.
In der Funktion setValues ist der Monat auf 0
und die Restschuld dem Kapital zu setzen.
Dann ist die Funktion getCredit wie folgt zu ändern:
| 1: |
| | 2: | bool Credit::getCredit()
| | 3: | {
| | 4: | //Restschuld = Kapital-Rate;
| | 5: | //Monat = 0;
| | 6: |
| | 7: | if (Restschuld > 0)
| | 8: | {
| | 9: | // Zinsen sind von der Restschuld zu berechnen
| | 10: |
| | 11: | float neueRestschuld = Restschuld;
| | 12: |
| | 13: | Zinsen = Restschuld*Zinssatz/100/12;
| | 14: | Tilgung = Rate-Zinsen;
| | 15: | neueRestschuld =Restschuld-Rate;
| | 16: |
| | 17: | // Erhöhe die Klassenvariable Monat um 1
| | 18: | Monat++;
| | 19: |
| | 20: | cout << setw(10) << Monat << fixed << setprecision(2) <<
| | 21: | " " << Restschuld << " " << fixed <<
| | 22: | setprecision(2) << " " << Zinsen << " " << fixed <<
| | 23: | setprecision(2) << " " << Tilgung << " " << endl
| | 24: | << endl;
| | 25: |
| | 26: | //Monat ++;
| | 27: | // Setze Restschuld auf neueRestschuld
| | 28: | Restschuld=neueRestschuld;
| | 29: |
| | 30: | return false;
| | 31: | }
| | 32: |
| | 33: | else if (Restschuld == 0)
| | 34: | {
| | 35: | return true;
| | 36: | }
| | 37: | }
|
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 21:12 Di 08.01.2013 | | Autor: | pina7 |
| 1: |
| | 2: | class Credit
| | 3: | {
| | 4: | protected:
| | 5: | float m_Kapital;
| | 6: | float m_Zinssatz;
| | 7: | float m_Rate;
| | 8: |
| | 9: | public:
| | 10: | float Kapital;
| | 11: | float Zinssatz;
| | 12: | float Rate;
| | 13: | int Monat;
| | 14: | float Restschuld; // Restschuld = Kapital-Rate
| | 15: |
| | 16: | float Zinsen; //Zinsen = Rate-Tilgung;
| | 17: | float Tilgung; //Tilgung = Rate-Zinsen;
| | 18: |
| | 19: | void setValues();
| | 20: | bool getCredit();
| | 21: | };
| | 22: |
| | 23: |
| | 24: | #include "stdafx.h"
| | 25: | #include <iostream>
| | 26: | #include "Credit.h"
| | 27: | #include <iomanip>
| | 28: |
| | 29: | using namespace std;
| | 30: |
| | 31: | void Credit::setValues()
| | 32: | {
| | 33: | m_Kapital = Kapital;
| | 34: | m_Zinssatz = Zinssatz;
| | 35: | m_Rate = Rate;
| | 36: | Monat = 0;
| | 37: | Restschuld = Kapital;
| | 38: | }
| | 39: |
| | 40: | bool Credit::getCredit()
| | 41: | {
| | 42: | if (Restschuld > 0)
| | 43: | {
| | 44: | float neueRestschuld = Restschuld;
| | 45: | Zinsen = Restschuld*Zinssatz/100/12; // Zinsen sind von der Restschuld zu berechnen
| | 46: | Tilgung = Rate-Zinsen;
| | 47: | neueRestschuld = Restschuld-Rate;
| | 48: | Monat ++; // Erhöhe die Klassenvariable Monat um 1
| | 49: |
| | 50: | cout << Monat << fixed << setprecision(2) << " " << Restschuld << " " << fixed << setprecision(2) << " " << Zinsen << " " << fixed << setprecision(2) << " " << Tilgung << " " << endl << endl;
| | 51: |
| | 52: | Restschuld=neueRestschuld; // Setze Restschuld auf neueRestschuld
| | 53: |
| | 54: | return false;
| | 55: | }
| | 56: |
| | 57: | else if (Restschuld == 0)
| | 58: | {
| | 59: | return true;
| | 60: | }
| | 61: | }
| | 62: |
| | 63: | int _tmain(int argc, _TCHAR* argv[])
| | 64: | {
| | 65: | Credit MyCredit;
| | 66: |
| | 67: | cout << "Kreditrueckzahlung" << endl << endl;
| | 68: | cout << "Bitte Kapital eingeben:" << endl << endl;
| | 69: | cin >> MyCredit.Kapital;
| | 70: | cout << "Bitte Zinssatz eingeben:" << endl << endl;
| | 71: | cin >> MyCredit.Zinssatz;
| | 72: | cout << "Bitte Rate eingeben:" << endl << endl;
| | 73: | cin >> MyCredit.Rate;
| | 74: |
| | 75: | MyCredit.setValues();
| | 76: |
| | 77: | cout << "Monat " << " Restschuld [Euro] " << " Zinsen [Euro] " << " Tilgung [Euro] " << endl << endl;
| | 78: |
| | 79: | MyCredit.getCredit();
| | 80: |
| | 81: | system("pause");
| | 82: | return 0;
| | 83: | }
|
Hallo und danke für die Hilfe. Es bleibt leider bei einem Funktionsdurchlauf, ich erhalte nur die erste Ausgabe. Was passt hier noch nicht? Danke
|
|
|
| |
|
Hallo pina7,
> | 1: |
| | 2: | > class Credit
| | 3: | > {
| | 4: | > protected:
| | 5: | > float m_Kapital;
| | 6: | > float m_Zinssatz;
| | 7: | > float m_Rate;
| | 8: | >
| | 9: | > public:
| | 10: | > float Kapital;
| | 11: | > float Zinssatz;
| | 12: | > float Rate;
| | 13: | > int Monat;
| | 14: | > float Restschuld; // Restschuld = Kapital-Rate
| | 15: | >
| | 16: | > float Zinsen; //Zinsen = Rate-Tilgung;
| | 17: | > float Tilgung; //Tilgung = Rate-Zinsen;
| | 18: | >
| | 19: | > void setValues();
| | 20: | > bool getCredit();
| | 21: | > };
| | 22: | >
| | 23: | >
| | 24: | > #include "stdafx.h"
| | 25: | > #include <iostream>
| | 26: | > #include "Credit.h"
| | 27: | > #include <iomanip>
| | 28: | >
| | 29: | > using namespace std;
| | 30: | >
| | 31: | > void Credit::setValues()
| | 32: | > {
| | 33: | > m_Kapital = Kapital;
| | 34: | > m_Zinssatz = Zinssatz;
| | 35: | > m_Rate = Rate;
| | 36: | > Monat = 0;
| | 37: | > Restschuld = Kapital;
| | 38: | > }
| | 39: | >
| | 40: | > bool Credit::getCredit()
| | 41: | > {
| | 42: | > if (Restschuld > 0)
| | 43: | > {
| | 44: | > float neueRestschuld = Restschuld;
| | 45: | > Zinsen = Restschuld*Zinssatz/100/12; // Zinsen sind von
| | 46: | > der Restschuld zu berechnen
| | 47: | > Tilgung = Rate-Zinsen;
| | 48: | > neueRestschuld = Restschuld-Rate;
| | 49: | > Monat ++; // Erhöhe die Klassenvariable Monat um
| | 50: | > 1
| | 51: | >
| | 52: | > cout << Monat << fixed << setprecision(2) << " "
| | 53: | > << Restschuld << " " << fixed << setprecision(2) <<
| | 54: | > " " << Zinsen << " " << fixed <<
| | 55: | > setprecision(2) << " " << Tilgung << " " <<
| | 56: | > endl << endl;
| | 57: | >
| | 58: | > Restschuld=neueRestschuld; // Setze Restschuld auf
| | 59: | > neueRestschuld
| | 60: | >
| | 61: | > return false;
| | 62: | > }
| | 63: | >
| | 64: | > else if (Restschuld == 0)
| | 65: | > {
| | 66: | > return true;
| | 67: | > }
| | 68: | > }
| | 69: | >
| | 70: | > int _tmain(int argc, _TCHAR* argv[])
| | 71: | > {
| | 72: | > Credit MyCredit;
| | 73: | >
| | 74: | > cout << "Kreditrueckzahlung" << endl << endl;
| | 75: | > cout << "Bitte Kapital eingeben:" << endl << endl;
| | 76: | > cin >> MyCredit.Kapital;
| | 77: | > cout << "Bitte Zinssatz eingeben:" << endl << endl;
| | 78: | > cin >> MyCredit.Zinssatz;
| | 79: | > cout << "Bitte Rate eingeben:" << endl << endl;
| | 80: | > cin >> MyCredit.Rate;
| | 81: | >
| | 82: | > MyCredit.setValues();
| | 83: | >
| | 84: | > cout << "Monat " << " Restschuld [Euro] " << "
| | 85: | > Zinsen [Euro] " << " Tilgung [Euro] " << endl <<
| | 86: | > endl;
| | 87: | >
| | 88: | > MyCredit.getCredit();
| | 89: | >
| | 90: | > system("pause");
| | 91: | > return 0;
| | 92: | > }
| | 93: | > |
>
> Hallo und danke für die Hilfe. Es bleibt leider bei einem
> Funktionsdurchlauf, ich erhalte nur die erste Ausgabe. Was
> passt hier noch nicht? Danke
Der Aufruf der Funktion getCredit ist in eine Schleife zu verpacken.
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 00:27 Mi 09.01.2013 | | Autor: | pina7 |
Hallo,
nun habe ich das Programm soweit, dass es mehrfach durchläuft.
Jedoch liefert es andere Ergebnisse als das Beispiel aus der Aufgabe.
Wenn ich die Werte 50000, 4% und 300 eingebe ist meine letzte ausgegebene Zeile
167 200.00 0.67 299.33
im Beispiel der Aufgabe ging es bis Monat 245.
Ich musste (habe) die Variablen Restschuld und neueRestschuld global definiert, sonst habe ich keinen Weg zum Schleifenverlauf "Aufruf der getPrice Funktion" gefunden. Könnte das daran liegen? Oder ist es, weil der Sonderfall letzte Rate (ich wüsste nicht wie ich das machen soll) nicht behandelt wurde?
Vielen Dank
| 1: |
| | 2: | class Credit
| | 3: | {
| | 4: | protected:
| | 5: | float m_Kapital;
| | 6: | float m_Zinssatz;
| | 7: | float m_Rate;
| | 8: |
| | 9: | public:
| | 10: | float Kapital;
| | 11: | float Zinssatz;
| | 12: | float Rate;
| | 13: | int Monat;
| | 14: |
| | 15: | float Zinsen; //Zinsen = Rate-Tilgung;
| | 16: | float Tilgung; //Tilgung = Rate-Zinsen;
| | 17: |
| | 18: | void setValues();
| | 19: | bool getCredit(float Restschuld);
| | 20: | };
| | 21: |
| | 22: | #include "stdafx.h"
| | 23: | #include <iostream>
| | 24: | #include "Credit.h"
| | 25: | #include <iomanip>
| | 26: |
| | 27: | using namespace std;
| | 28: |
| | 29: | float Restschuld;
| | 30: | float neueRestschuld;
| | 31: |
| | 32: | void Credit::setValues()
| | 33: | {
| | 34: | m_Kapital = Kapital;
| | 35: | m_Zinssatz = Zinssatz;
| | 36: | m_Rate = Rate;
| | 37: | Monat = 0;
| | 38: | Restschuld = Kapital;
| | 39: | }
| | 40: |
| | 41: | bool Credit::getCredit(float Restschuld)
| | 42: | {
| | 43: | if (Restschuld > 0)
| | 44: | {
| | 45: | neueRestschuld = Restschuld;
| | 46: | Zinsen = Restschuld*Zinssatz/100/12; // Zinsen sind von der Restschuld zu berechnen
| | 47: | Tilgung = Rate-Zinsen;
| | 48: | neueRestschuld = Restschuld-Rate;
| | 49: | Monat ++; // Erhöhe die Klassenvariable Monat um 1
| | 50: |
| | 51: | cout << Monat << fixed << setprecision(2) << " " << Restschuld << " " << fixed << setprecision(2) << " " << Zinsen << " " << fixed << setprecision(2) << " " << Tilgung << " " << endl << endl;
| | 52: |
| | 53: | Restschuld=neueRestschuld; // Setze Restschuld auf neueRestschuld
| | 54: |
| | 55: | return Restschuld, false;
| | 56: | }
| | 57: |
| | 58: | else if (Restschuld == 0)
| | 59: | {
| | 60: | return true;
| | 61: | }
| | 62: | }
| | 63: |
| | 64: | int _tmain(int argc, _TCHAR* argv[])
| | 65: | {
| | 66: | int Programmwiederholung = 0;
| | 67: |
| | 68: | do
| | 69: | {
| | 70: |
| | 71: | system("cls");
| | 72: |
| | 73: | Credit MyCredit;
| | 74: |
| | 75: | cout << "Kreditrueckzahlung" << endl << endl;
| | 76: | cout << "Bitte Kapital eingeben:" << endl << endl;
| | 77: | cin >> MyCredit.Kapital;
| | 78: | cout << "Bitte Zinssatz eingeben:" << endl << endl;
| | 79: | cin >> MyCredit.Zinssatz;
| | 80: | cout << "Bitte Rate eingeben:" << endl << endl;
| | 81: | cin >> MyCredit.Rate;
| | 82: |
| | 83: | MyCredit.setValues();
| | 84: |
| | 85: | cout << "Monat " << " Restschuld [Euro] " << " Zinsen [Euro] " << " Tilgung [Euro] " << endl << endl;
| | 86: |
| | 87: | do
| | 88: | {
| | 89: | MyCredit.getCredit(Restschuld);
| | 90: | Restschuld=neueRestschuld;
| | 91: | }while (Restschuld > 0);
| | 92: |
| | 93: | cout << "0 fuer erneute Berechnung, andernfalls 1 eingeben:" << endl << endl;
| | 94: | cin >> Programmwiederholung;
| | 95: |
| | 96: | }while (Programmwiederholung == 0);
| | 97: |
| | 98: | system("pause");
| | 99: | return 0;
| | 100: |
| | 101: | }
|
|
|
|
| |
|
Hallo pina7,
> Hallo,
>
> nun habe ich das Programm soweit, dass es mehrfach
> durchläuft.
> Jedoch liefert es andere Ergebnisse als das Beispiel aus
> der Aufgabe.
> Wenn ich die Werte 50000, 4% und 300 eingebe ist meine
> letzte ausgegebene Zeile
> 167 200.00 0.67 299.33
>
> im Beispiel der Aufgabe ging es bis Monat 245.
>
> Ich musste (habe) die Variablen Restschuld und
> neueRestschuld global definiert, sonst habe ich keinen Weg
Die Variable "Restschuld" ist doch eine Klassenvariable,
daher ist sie nicht global zu definieren.
> zum Schleifenverlauf "Aufruf der getPrice Funktion"
Hier bringst Du etwas durcheinander.
Die getPrice-Funktion war beim Spielzeugladen gefragt.
> gefunden. Könnte das daran liegen? Oder ist es, weil der
> Sonderfall letzte Rate (ich wüsste nicht wie ich das
> machen soll) nicht behandelt wurde?
Nein.
Die Funktion getCredit() hat keinen Parameter.
Der mehrfache Schleifendurchlauf
wird durch eine einfache Schleife realisiert:
| 1: |
| | 2: | while ( !MyCredit.getCredit())
| | 3: | {
| | 4: | }
|
Dann ist ebn noch der Fall der letzten Rate zu behandeln.
> Vielen Dank
> | 1: |
| | 2: | > class Credit
| | 3: | > {
| | 4: | > protected:
| | 5: | > float m_Kapital;
| | 6: | > float m_Zinssatz;
| | 7: | > float m_Rate;
| | 8: | >
| | 9: | > public:
| | 10: | > float Kapital;
| | 11: | > float Zinssatz;
| | 12: | > float Rate;
| | 13: | > int Monat;
| | 14: | >
| | 15: | > float Zinsen; //Zinsen = Rate-Tilgung;
| | 16: | > float Tilgung; //Tilgung = Rate-Zinsen;
| | 17: | >
| | 18: | > void setValues();
| | 19: | > bool getCredit(float Restschuld);
| | 20: | > };
| | 21: | >
| | 22: | > #include "stdafx.h"
| | 23: | > #include <iostream>
| | 24: | > #include "Credit.h"
| | 25: | > #include <iomanip>
| | 26: | >
| | 27: | > using namespace std;
| | 28: | >
| | 29: | > float Restschuld;
| | 30: | > float neueRestschuld;
| | 31: | >
| | 32: | > void Credit::setValues()
| | 33: | > {
| | 34: | > m_Kapital = Kapital;
| | 35: | > m_Zinssatz = Zinssatz;
| | 36: | > m_Rate = Rate;
| | 37: | > Monat = 0;
| | 38: | > Restschuld = Kapital;
| | 39: | > }
| | 40: | >
| | 41: | > bool Credit::getCredit(float Restschuld)
| | 42: | > {
| | 43: | > if (Restschuld > 0)
| | 44: | > {
| | 45: | > neueRestschuld = Restschuld;
| | 46: | > Zinsen = Restschuld*Zinssatz/100/12; // Zinsen sind von
| | 47: | > der Restschuld zu berechnen
| | 48: | > Tilgung = Rate-Zinsen;
| | 49: | > neueRestschuld = Restschuld-Rate;
| | 50: | > Monat ++; // Erhöhe die Klassenvariable Monat um 1
| | 51: | >
| | 52: | > cout << Monat << fixed << setprecision(2) << "
| | 53: | > " << Restschuld << " " << fixed << setprecision(2)
| | 54: | > << " " << Zinsen << " " << fixed <<
| | 55: | > setprecision(2) << " " << Tilgung << " " <<
| | 56: | > endl << endl;
| | 57: | >
| | 58: | > Restschuld=neueRestschuld; // Setze Restschuld auf
| | 59: | > neueRestschuld
| | 60: | >
| | 61: | > return Restschuld, false;
| | 62: | > }
| | 63: | >
| | 64: | > else if (Restschuld == 0)
| | 65: | > {
| | 66: | > return true;
| | 67: | > }
| | 68: | > }
| | 69: | >
| | 70: | > int _tmain(int argc, _TCHAR* argv[])
| | 71: | > {
| | 72: | > int Programmwiederholung = 0;
| | 73: | >
| | 74: | > do
| | 75: | > {
| | 76: | >
| | 77: | > system("cls");
| | 78: | >
| | 79: | > Credit MyCredit;
| | 80: | >
| | 81: | > cout << "Kreditrueckzahlung" << endl << endl;
| | 82: | > cout << "Bitte Kapital eingeben:" << endl << endl;
| | 83: | > cin >> MyCredit.Kapital;
| | 84: | > cout << "Bitte Zinssatz eingeben:" << endl << endl;
| | 85: | > cin >> MyCredit.Zinssatz;
| | 86: | > cout << "Bitte Rate eingeben:" << endl << endl;
| | 87: | > cin >> MyCredit.Rate;
| | 88: | >
| | 89: | > MyCredit.setValues();
| | 90: | >
| | 91: | > cout << "Monat " << " Restschuld [Euro] " << "
| | 92: | > Zinsen [Euro] " << " Tilgung [Euro] " << endl <<
| | 93: | > endl;
| | 94: | >
| | 95: | > do
| | 96: | > {
| | 97: | > MyCredit.getCredit(Restschuld);
| | 98: | > Restschuld=neueRestschuld;
| | 99: | > }while (Restschuld > 0);
| | 100: | >
| | 101: | > cout << "0 fuer erneute Berechnung, andernfalls 1
| | 102: | > eingeben:" << endl << endl;
| | 103: | > cin >> Programmwiederholung;
| | 104: | >
| | 105: | > }while (Programmwiederholung == 0);
| | 106: | >
| | 107: | > system("pause");
| | 108: | > return 0;
| | 109: | >
| | 110: | > }
| | 111: | > |
>
Gruss
MathePower
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 20:27 Mi 09.01.2013 | | Autor: | pina7 |
Hallo und erneut vielen Dank. Der Hinweis mit while (!MyCredit.getCredit()){} ist schön, das kannte ich so noch nicht.
Aber... es bleibt dabei, dass das Programm bei Zeile 167 schon beim Ende der Rückzahlung angekommen ist. Ich habe das mit Excel (Sonderfall letzte Rate nicht berücksichtigt) überprüft, und es sind 245 Monate wie im Beispiel der Aufgabe. Desweiteren weiß ich nicht, wie man die letzte Rate berechnet, habe hierzu keine Formel gefunden. Viele Grüße
| 1: |
| | 2: | class Credit
| | 3: | {
| | 4: | protected:
| | 5: | float m_Kapital;
| | 6: | float m_Zinssatz;
| | 7: | float m_Rate;
| | 8: |
| | 9: | public:
| | 10: | float Kapital;
| | 11: | float Zinssatz;
| | 12: | float Rate;
| | 13: | int Monat;
| | 14: |
| | 15: | float Restschuld;
| | 16: | float Zinsen; //Zinsen = Rate-Tilgung;
| | 17: | float Tilgung; //Tilgung = Rate-Zinsen;
| | 18: |
| | 19: | void setValues();
| | 20: | bool getCredit();
| | 21: | };
| | 22: |
| | 23: | #include "stdafx.h"
| | 24: | #include <iostream>
| | 25: | #include "Credit.h"
| | 26: | #include <iomanip>
| | 27: |
| | 28: | using namespace std;
| | 29: |
| | 30: | void Credit::setValues()
| | 31: | {
| | 32: | m_Kapital = Kapital;
| | 33: | m_Zinssatz = Zinssatz;
| | 34: | m_Rate = Rate;
| | 35: | Monat = 0;
| | 36: | Restschuld = Kapital;
| | 37: | }
| | 38: |
| | 39: | bool Credit::getCredit()
| | 40: | {
| | 41: | if (Restschuld > 0)
| | 42: | {
| | 43: | float neueRestschuld;
| | 44: | neueRestschuld = Restschuld;
| | 45: | Zinsen = Restschuld*Zinssatz/100/12; // Zinsen sind von der Restschuld zu berechnen
| | 46: | Tilgung = Rate-Zinsen;
| | 47: | neueRestschuld = Restschuld-Rate;
| | 48: |
| | 49: | Monat ++; // Erhöhe die Klassenvariable Monat um 1
| | 50: |
| | 51: | cout << Monat << fixed << setprecision(2) << " " << Restschuld << " " << fixed << setprecision(2) << " " << Zinsen << " " << fixed << setprecision(2) << " " << Tilgung << " " << endl << endl;
| | 52: |
| | 53: | Restschuld=neueRestschuld; // Setze Restschuld auf neueRestschuld
| | 54: |
| | 55: | return false;
| | 56: | }
| | 57: |
| | 58: | else if (Restschuld == 0)
| | 59: | {
| | 60: | return true;
| | 61: | }
| | 62: | }
| | 63: |
| | 64: | int _tmain(int argc, _TCHAR* argv[])
| | 65: | {
| | 66: | int Programmwiederholung = 0;
| | 67: |
| | 68: | do
| | 69: | {
| | 70: | system("cls");
| | 71: |
| | 72: | Credit MyCredit;
| | 73: |
| | 74: | cout << "Kreditrueckzahlung" << endl << endl;
| | 75: | cout << "Bitte Kapital eingeben:" << endl << endl;
| | 76: | cin >> MyCredit.Kapital;
| | 77: | cout << "Bitte Zinssatz eingeben:" << endl << endl;
| | 78: | cin >> MyCredit.Zinssatz;
| | 79: | cout << "Bitte Rate eingeben:" << endl << endl;
| | 80: | cin >> MyCredit.Rate;
| | 81: |
| | 82: | MyCredit.setValues();
| | 83: |
| | 84: | cout << "Monat " << " Restschuld [Euro] " << " Zinsen [Euro] " << " Tilgung [Euro] " << endl << endl;
| | 85: |
| | 86: | while (!MyCredit.getCredit())
| | 87: | {
| | 88: | }
| | 89: |
| | 90: | cout << "0 fuer erneute Berechnung, andernfalls 1 eingeben:" << endl << endl;
| | 91: | cin >> Programmwiederholung;
| | 92: |
| | 93: | }while (Programmwiederholung == 0);
| | 94: |
| | 95: | system("pause");
| | 96: | return 0;
| | 97: | }
|
|
|
|
| |
|
Hallo pina7,
> Hallo und erneut vielen Dank. Der Hinweis mit while
> (!MyCredit.getCredit()){} ist schön, das kannte ich so
> noch nicht.
> Aber... es bleibt dabei, dass das Programm bei Zeile 167
Die neue Restschuld berechnet sich doch so:
| 1: |
| | 2: | neueRestschuld=Restschuld-Tilgung;
|
In Deinem Programmcode wird die neue Restschuld so berechnet:
| 1: |
| | 2: | neueRestschuld=Restschuld-Rate;
|
> schon beim Ende der Rückzahlung angekommen ist. Ich habe
> das mit Excel (Sonderfall letzte Rate nicht
> berücksichtigt) überprüft, und es sind 245 Monate wie im
> Beispiel der Aufgabe. Desweiteren weiß ich nicht, wie man
> die letzte Rate berechnet, habe hierzu keine Formel
> gefunden. Viele Grüße
> | 1: |
| | 2: | > class Credit
| | 3: | > {
| | 4: | > protected:
| | 5: | > float m_Kapital;
| | 6: | > float m_Zinssatz;
| | 7: | > float m_Rate;
| | 8: | >
| | 9: | > public:
| | 10: | > float Kapital;
| | 11: | > float Zinssatz;
| | 12: | > float Rate;
| | 13: | > int Monat;
| | 14: | >
| | 15: | > float Restschuld;
| | 16: | > float Zinsen; //Zinsen = Rate-Tilgung;
| | 17: | > float Tilgung; //Tilgung = Rate-Zinsen;
| | 18: | >
| | 19: | > void setValues();
| | 20: | > bool getCredit();
| | 21: | > };
| | 22: | >
| | 23: | > #include "stdafx.h"
| | 24: | > #include <iostream>
| | 25: | > #include "Credit.h"
| | 26: | > #include <iomanip>
| | 27: | >
| | 28: | > using namespace std;
| | 29: | >
| | 30: | > void Credit::setValues()
| | 31: | > {
| | 32: | > m_Kapital = Kapital;
| | 33: | > m_Zinssatz = Zinssatz;
| | 34: | > m_Rate = Rate;
| | 35: | > Monat = 0;
| | 36: | > Restschuld = Kapital;
| | 37: | > }
| | 38: | >
| | 39: | > bool Credit::getCredit()
| | 40: | > {
| | 41: | > if (Restschuld > 0)
| | 42: | > {
| | 43: | > float neueRestschuld;
| | 44: | > neueRestschuld = Restschuld;
| | 45: | > Zinsen = Restschuld*Zinssatz/100/12; // Zinsen sind von
| | 46: | > der Restschuld zu berechnen
| | 47: | > Tilgung = Rate-Zinsen;
| | 48: | > neueRestschuld = Restschuld-Rate;
| | 49: | >
| | 50: | > Monat ++; // Erhöhe die Klassenvariable Monat um 1
| | 51: | >
| | 52: | > cout << Monat << fixed << setprecision(2) << "
| | 53: | > " << Restschuld << " " << fixed << setprecision(2)
| | 54: | > << " " << Zinsen << " " << fixed <<
| | 55: | > setprecision(2) << " " << Tilgung << " " <<
| | 56: | > endl << endl;
| | 57: | >
| | 58: | > Restschuld=neueRestschuld; // Setze Restschuld auf
| | 59: | > neueRestschuld
| | 60: | >
| | 61: | > return false;
| | 62: | > }
| | 63: | >
| | 64: | > else if (Restschuld == 0)
| | 65: | > {
| | 66: | > return true;
| | 67: | > }
| | 68: | > }
| | 69: | >
| | 70: | > int _tmain(int argc, _TCHAR* argv[])
| | 71: | > {
| | 72: | > int Programmwiederholung = 0;
| | 73: | >
| | 74: | > do
| | 75: | > {
| | 76: | > system("cls");
| | 77: | >
| | 78: | > Credit MyCredit;
| | 79: | >
| | 80: | > cout << "Kreditrueckzahlung" << endl << endl;
| | 81: | > cout << "Bitte Kapital eingeben:" << endl << endl;
| | 82: | > cin >> MyCredit.Kapital;
| | 83: | > cout << "Bitte Zinssatz eingeben:" << endl << endl;
| | 84: | > cin >> MyCredit.Zinssatz;
| | 85: | > cout << "Bitte Rate eingeben:" << endl << endl;
| | 86: | > cin >> MyCredit.Rate;
| | 87: | >
| | 88: | > MyCredit.setValues();
| | 89: | >
| | 90: | > cout << "Monat " << " Restschuld [Euro] " << "
| | 91: | > Zinsen [Euro] " << " Tilgung [Euro] " << endl <<
| | 92: | > endl;
| | 93: | >
| | 94: | > while (!MyCredit.getCredit())
| | 95: | > {
| | 96: | > }
| | 97: | >
| | 98: | > cout << "0 fuer erneute Berechnung, andernfalls 1
| | 99: | > eingeben:" << endl << endl;
| | 100: | > cin >> Programmwiederholung;
| | 101: | >
| | 102: | > }while (Programmwiederholung == 0);
| | 103: | >
| | 104: | > system("pause");
| | 105: | > return 0;
| | 106: | > }
| | 107: | > |
Gruss
MathePower
|
|
|
|
