Brauche Hilfe bei meinem Taschenrechner!

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Brauche Hilfe bei meinem Taschenrechner!

    Ich bräuchte Hilfe bei meinem Taschenrechner.
    Das Problem ist das die Schleife bei mehrfacheingabe wegen dem getch() so oft ausgefürt, bis die im getch eingegebenen eingaben abgearbeitet sind.
    Hier der Code:

    Quellcode

    1. // Taschenrechner.cpp : ein Taschenrechner mit Auswahl, Schleife und Modulen.
    3. #include "stdafx.h"
    4. #include <iostream>
    5. #include <conio.h>
    6. #include <tchar.h>
    8. using namespace std;
    10. // Auswahl der Rechenart.
    11. char f_wahl(char wahl)
    12. {
    13. cout << "Bitte geben Sie die gew"<<(char)129<<"nschte Funktion ein" << endl;
    14. cout << "1 f"<<(char)129<<"r Addition. \n2 f"<<(char)129<<"r Subtraktion. \n3 f"<<(char)129<<"r Multiplikation. \n4 f"<<(char)129<<"r Division." << endl;
    15. cin >> wahl;
    16. return wahl;
    17. };
    19. // Hier werden die Werte eingegeben, wenn das Programm gestarten wird oder wenn das alte Ergebnis verworfen werden soll.
    20. void p_eingabe_n(double &wert1, double &wert2)
    21. {
    22. cout << "Bitte geben Sie jetzt die erste Zahl ein." << endl;
    23. cin >> wert1;
    24. cout << "Jetzt bitte die zweite Zahl." << endl;
    25. cin >> wert2;
    26. };
    28. // Hier wird der zweite Wert eingegeben, wenn mit einem ergebnis weiter gearbeitet wird.
    29. void p_eingabe_w(double &wert2)
    30. {
    31. cout << "Bitte geben sie die zweite Zahl ein." << endl;
    32. cin >> wert2;
    33. };
    35. // Hier wird eine Falsche eingabe angefangen, wenn vorher noch kein Ergebnis vorhanden war.
    36. void p_abfang(char &cTaste)
    37. {
    38. do
    39. {
    40. cout << "\nWollen Sie mit dem Taschenrechner weiter arbeiten? \n\nj fuer ja\na zum aufzuhoeren" << endl;
    41. cTaste=getch();
    42. }
    43. // Hier musste leider a und j genutzt werden, um nicht durch andere Abfragen fehlgeleitet zu werden.
    44. while((cTaste!='j')&&(cTaste!='a'));
    45. };
    47. // die addition mit den Werten aus p_eingabe_n oder p_eingabe_w.
    48. double f_addition(double wert1, double wert2)
    49. {
    50. double ergebnis=0;
    51. ergebnis=wert1+wert2;
    52. return ergebnis;
    53. };
    55. // die subtraktion mit den Werten aus p_eingabe_n oder p_eingabe_w.
    56. double f_subtraktion(double wert1, double wert2)
    57. {
    58. double ergebnis=0;
    59. ergebnis=wert1-wert2;
    60. return ergebnis;
    61. };
    63. // die multiplikation mit den Werten aus p_eingabe_n oder p_eingabe_w.
    64. double f_multiplikation(double wert1, double wert2)
    65. {
    66. double ergebnis=0;
    67. ergebnis=wert1*wert2;
    68. return ergebnis;
    69. };
    71. // die addition mit den Werten aus p_eingabe_n.
    72. double f_division_n(double wert1, double wert2, char &cTaste)
    73. {
    74. double ergebnis=0;
    76. // Hier wird die Division durch 0 abgefangen.
    77. if (wert2 == 0)
    78. {
    79. cout << "Die Division durch " << wert2 << " ist nicht moeglich!";
    81. // cTaste wird auf d gesetzt damit zwischen einem fehler ohne vorherigen und
    82. // mit vorherigen Ergebnis unterschieden werden kann.
    83. cTaste='d';
    84. }
    85. else
    86. ergebnis=wert1/wert2;
    88. return ergebnis;
    90. };
    92. // die division mit den Werten aus p_eingabe_w.
    93. double f_division_w(double wert1, double wert2, char &cTaste)
    94. {
    95. double ergebnis=0;
    96. if (wert2 == 0)
    97. {
    98. cout << "Die Division durch " << wert2 << " ist nicht moeglich!" << endl;
    99. cout << "Die erste Zahl wird wieder auf ihr altes Ergebnis zurueck gesetzt" << endl;
    101. // cTaste wird auf d gesetzt damit zwischen einem fehler ohne vorherigen und
    102. // mit vorherigen Ergebnis unterschieden werden kann.
    103. cTaste='g';
    104. }
    106. else
    107. ergebnis=wert1/wert2;
    109. return ergebnis;
    111. };
    114. // Wird aufgerufen beim ersten Programm durchlauf oder bei neu berechnung.
    115. void p_switch_n(char &cTaste, char wahl, double wert1, double wert2, double &ergebnis)
    116. {
    117. switch (wahl)
    118. {
    119. case '1': p_eingabe_n(wert1,wert2);
    120. ergebnis=f_addition(wert1,wert2); break;
    122. case '2': p_eingabe_n(wert1,wert2);
    123. ergebnis=f_subtraktion(wert1,wert2); break;
    125. case '3': p_eingabe_n(wert1,wert2);
    126. ergebnis=f_multiplikation(wert1,wert2); break;
    128. case '4': p_eingabe_n(wert1,wert2);
    129. ergebnis=f_division_n(wert1,wert2,cTaste);break;
    131. default: cout << endl << wahl << " ist keine g"<<(char)129<<"ltige Eingabe!";
    132. p_abfang(cTaste);
    133. };
    134. };
    136. // Wird durchlaufen wenn mit dem Ergebnis aus case n weiter rechne.
    137. void p_switch_w(char &cTaste, char wahl, double wert1, double wert2, double &ergebnis)
    138. {
    139. switch (wahl)
    140. {
    141. case '1': p_eingabe_w(wert2);
    142. ergebnis=f_addition(wert1,wert2); break;
    144. case '2': p_eingabe_w(wert2);
    145. ergebnis=f_subtraktion(wert1,wert2); break;
    147. case '3': p_eingabe_w(wert2);
    148. ergebnis=f_multiplikation(wert1,wert2); break;
    150. case '4': p_eingabe_w(wert2);
    151. ergebnis=f_division_w(wert1, wert2, cTaste); break;
    153. default: cTaste='g';
    154. };
    155. };
    157. // Kommt nach einer Division durch 0 ohne vorherigen Ergebnis.
    158. char f_schluss(double ergebnis,double &wert1 , char cTaste)
    159. {
    160. if (cTaste == 'd')
    161. p_abfang(cTaste);
    163. // Ausgabe des Ergebnis wenn der Anwender keine Fehler gemacht hat.
    164. else if (cTaste=='n' || cTaste=='w')
    165. {
    166. cout << endl << "das Ergebnis lautet " << ergebnis << endl;
    167. wert1=ergebnis;
    169. cout << endl << "Esc zum Abbrechen." << endl;
    170. cout << "w um das Ergebnis weiter zu nutzen.";
    171. cout << endl << "n um die alten werte zu verwerfen." << endl;
    172. cTaste = getch();
    173. }
    174. // Kommt nach einer Division durch 0 mit einem vorhandenen ergebnis.
    175. else if (cTaste == 'g')
    176. {
    177. cout << endl << "Esc zum Abbrechen." << endl;
    178. cout << "w dr"<<(char)129<<"cken um mit dem alten Ergebnis weiter zu arbeiten." << endl;
    179. cout << "n um die alten werte zu verwerfen." << endl;
    180. cTaste = getch();
    181. }
    183. return cTaste;
    184. };
    186. // Hier wird jede falsche Eingabe abgefangen, wenn das Programm min. einmal erfolgreich
    187. // durchgelaufen wurde und mit dem Ergebnis weiter gearbeitet wurde.
    188. char f_abfang(char cTaste)
    189. {
    190. do
    191. {
    192. cout << "\nIhnen stehen folgene Optionen zu verf"<<(char)129<<"gung: \n\nn fuer eine neue Berechnung.";
    193. cout << "\nw um mit dem Ergebnis weiter zu arbeiten.\nEsc fuer Abbruch." << endl;
    194. cTaste=getch();
    195. }
    196. while((cTaste !=27)&&(cTaste !='w')&&(cTaste !='n'));
    197. return cTaste;
    198. };
    200. void main(void)
    201. {
    202. double wert1=0;
    203. double wert2=0;
    204. double ergebnis=0;
    205. char wahl=' ';
    206. char cTaste = 'n';
    209. do
    210. { // Damit nicht unnötig und falscherweise Text ausgegeben wird,
    211. // kommt man hier nur mit gültigen Werten rein.
    212. if (cTaste=='n' || cTaste=='w')
    213. {
    214. // Löscht das Fenster und der Text erscheint neu.
    215. system("cls");
    217. // Abfrage der Grundrechenarten.
    218. wahl=f_wahl(wahl);
    220. // Durch dieses switch/case wird das Arbeiten mit vorherrigen Ergebnis realisiert.
    221. switch (cTaste)
    222. {
    223. case 'n': p_switch_n(cTaste,wahl,wert1,wert2,ergebnis);break; // Auslagerung der Case.
    224. case 'w': p_switch_w(cTaste,wahl,wert1,wert2,ergebnis);break; // Auslagerung der Case.
    225. default:;
    226. }
    227. }
    228. // Hier werden richtige Durchläufe abgefangen und das Ergebnis dem Anwender ausgegeben.
    229. if (cTaste=='d' || cTaste=='g' || cTaste=='n' || cTaste=='w')
    230. cTaste=f_schluss(ergebnis,wert1,cTaste);
    232. // Hier wird der Rückwert einer abfang Schleife abgefangen und ans Konzept angepasst.
    233. else if (cTaste=='a')
    234. cTaste=27;
    236. // Hier wird der Rückwert einer abfang Schleife abgefangen und ans Konzept angepasst.
    237. else if (cTaste=='j')
    238. cTaste='n';
    240. // Das ist die letzte Abfang möglichkeit, wenn cTaste weder d,g,n,w,j,a oder Esc ist.
    241. else if (cTaste != 27)
    242. cTaste=f_abfang(cTaste);
    244. }
    245. // Abbruchbedingung für den Taschenrechner (27 steht in der ASCII-Tabelle für die Esc Taste
    246. while(cTaste != 27);
    247. };
    Alles anzeigen