Coder Forum

C Quellcode

// Taschenrechner.cpp : ein Taschenrechner mit Auswahl, Schleife und Modulen.
 
#include "stdafx.h"
#include <iostream>
#include <conio.h>
#include <tchar.h>
 
using namespace std;
 
// Auswahl der Rechenart.
char f_wahl(char wahl)
{
	cout << "Bitte geben Sie die gew"<<(char)129<<"nschte Funktion ein" << endl;
	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;
	cin  >> wahl;
	return wahl;
};
 
// Hier werden die Werte eingegeben, wenn das Programm gestarten wird oder wenn das alte Ergebnis verworfen werden soll.
void p_eingabe_n(double &wert1, double &wert2) 
{
	cout << "Bitte geben Sie jetzt die erste Zahl ein." << endl;
	cin  >> wert1;
	cout << "Jetzt bitte die zweite Zahl." << endl;
	cin  >> wert2;
};
 
// Hier wird der zweite Wert eingegeben, wenn mit einem ergebnis weiter gearbeitet wird.
void p_eingabe_w(double &wert2) 
{
	cout << "Bitte geben sie die zweite Zahl ein." << endl;
	cin  >> wert2;
};
 
// Hier wird eine Falsche eingabe angefangen, wenn vorher noch kein Ergebnis vorhanden war.
void p_abfang(char &cTaste) 
{
	do
	{
		cout << "\nWollen Sie mit dem Taschenrechner weiter arbeiten? \n\nj fuer ja\na zum aufzuhoeren" << endl;
		cTaste=getch();
	}
	// Hier musste leider a und j genutzt werden, um nicht durch andere Abfragen fehlgeleitet zu werden.
	while((cTaste!='j')&&(cTaste!='a')); 
};										 
 
// die addition mit den Werten aus p_eingabe_n oder p_eingabe_w.
double f_addition(double wert1, double wert2) 
{
	double ergebnis=0;
	ergebnis=wert1+wert2;
	return  ergebnis;
};
 
// die subtraktion mit den Werten aus p_eingabe_n oder p_eingabe_w.
double f_subtraktion(double wert1, double wert2) 
{
	double ergebnis=0;
	ergebnis=wert1-wert2;
	return  ergebnis;
};
 
// die multiplikation mit den Werten aus p_eingabe_n oder p_eingabe_w.
double f_multiplikation(double wert1, double wert2) 
{
	double ergebnis=0;
	ergebnis=wert1*wert2;
	return  ergebnis;
};
 
// die addition mit den Werten aus p_eingabe_n.
double f_division_n(double wert1, double wert2, char &cTaste) 
{
	double ergebnis=0;
 
	 // Hier wird die Division durch 0 abgefangen.
	if (wert2 == 0)
	{
		cout << "Die Division durch " << wert2 << " ist nicht moeglich!";
 
		// cTaste wird auf d gesetzt damit zwischen einem fehler ohne vorherigen und  
		// mit vorherigen Ergebnis unterschieden werden kann.
		cTaste='d'; 
	}				
	else	
		ergebnis=wert1/wert2;
 
	return  ergebnis;
 
};
 
// die division mit den Werten aus p_eingabe_w.
double f_division_w(double wert1, double wert2, char &cTaste) 
{
	double ergebnis=0;
	if (wert2 == 0)
	{
		cout << "Die Division durch " << wert2 << " ist nicht moeglich!" << endl; 
		cout << "Die erste Zahl wird wieder auf ihr altes Ergebnis zurueck gesetzt" << endl;
 
		// cTaste wird auf d gesetzt damit zwischen einem fehler ohne vorherigen und
		// mit vorherigen Ergebnis unterschieden werden kann.
		cTaste='g'; 
	}				
 
		else		
			ergebnis=wert1/wert2;
 
	return  ergebnis;
 
};
 
 
// Wird aufgerufen beim ersten Programm durchlauf oder bei neu berechnung.
void p_switch_n(char &cTaste, char wahl, double wert1, double wert2, double &ergebnis)
{	
	switch (wahl) 
	{
		case '1': p_eingabe_n(wert1,wert2);
				ergebnis=f_addition(wert1,wert2); break;
 
		case '2': p_eingabe_n(wert1,wert2);
				ergebnis=f_subtraktion(wert1,wert2); break;
 
		case '3': p_eingabe_n(wert1,wert2);
				ergebnis=f_multiplikation(wert1,wert2); break;
 
		case '4': p_eingabe_n(wert1,wert2);
				ergebnis=f_division_n(wert1,wert2,cTaste);break;
 
		default: cout << endl << wahl << " ist keine g"<<(char)129<<"ltige Eingabe!";
				p_abfang(cTaste);
	};
};
 
// Wird durchlaufen wenn mit dem Ergebnis aus case n weiter rechne.
void p_switch_w(char &cTaste, char wahl, double wert1, double wert2, double &ergebnis)
{	
	switch (wahl) 
	{
		case '1': p_eingabe_w(wert2);
				ergebnis=f_addition(wert1,wert2); break;
 
		case '2': p_eingabe_w(wert2);
				ergebnis=f_subtraktion(wert1,wert2); break;
 
		case '3': p_eingabe_w(wert2);
				ergebnis=f_multiplikation(wert1,wert2); break;
 
		case '4': p_eingabe_w(wert2);
				ergebnis=f_division_w(wert1, wert2, cTaste); break;
 
		default: cTaste='g';
	};
};
 
// Kommt nach einer Division durch 0 ohne vorherigen Ergebnis.
char f_schluss(double ergebnis,double &wert1 , char cTaste)
{
	if (cTaste == 'd') 
		p_abfang(cTaste);
 
			// Ausgabe des Ergebnis wenn der Anwender keine Fehler gemacht hat.
	    else if (cTaste=='n' || cTaste=='w') 
			{
				cout << endl << "das Ergebnis lautet " << ergebnis << endl;
				wert1=ergebnis;
 
				cout << endl << "Esc zum Abbrechen." << endl;
				cout << "w um das Ergebnis weiter zu nutzen.";
				cout << endl << "n um die alten werte zu verwerfen." << endl;
				cTaste = getch();
			}
				// Kommt nach einer Division durch 0 mit einem vorhandenen ergebnis.
			else if (cTaste == 'g')
				{
					cout << endl << "Esc zum Abbrechen." << endl;
					cout << "w dr"<<(char)129<<"cken um mit dem alten Ergebnis weiter zu arbeiten." << endl;
					cout << "n um die alten werte zu verwerfen." << endl;
					cTaste = getch();	
				}
 
 return cTaste;
};
 
// Hier wird jede falsche Eingabe abgefangen, wenn das Programm min. einmal erfolgreich
// durchgelaufen wurde und mit dem Ergebnis weiter gearbeitet wurde.
char f_abfang(char cTaste) 
{						   
	do
	{
		cout << "\nIhnen stehen folgene Optionen zu verf"<<(char)129<<"gung: \n\nn fuer eine neue Berechnung.";
		cout << "\nw um mit dem Ergebnis weiter zu arbeiten.\nEsc fuer Abbruch." << endl;
		cTaste=getch();
	}
	while((cTaste !=27)&&(cTaste !='w')&&(cTaste !='n'));
return cTaste;
};
 
void main(void)
{
 	double wert1=0;
	double wert2=0;
	double ergebnis=0;
	char wahl=' ';
	char cTaste = 'n';
 
 
	do
	{	// Damit nicht unnötig und falscherweise Text ausgegeben wird,
		// kommt man hier nur mit gültigen Werten rein.
		if (cTaste=='n' || cTaste=='w')	
		{								
			// Löscht das Fenster und der Text erscheint neu.
			system("cls"); 
 
			// Abfrage der Grundrechenarten.
			wahl=f_wahl(wahl);
 
			// Durch dieses switch/case wird das Arbeiten mit vorherrigen Ergebnis realisiert.
			switch (cTaste) 
			{
				case 'n':   p_switch_n(cTaste,wahl,wert1,wert2,ergebnis);break;	// Auslagerung der Case.	
				case 'w':	p_switch_w(cTaste,wahl,wert1,wert2,ergebnis);break;	// Auslagerung der Case.		
				default:;
			}
		}
		// Hier werden richtige Durchläufe abgefangen und das Ergebnis dem Anwender ausgegeben.
		if (cTaste=='d' || cTaste=='g' || cTaste=='n' || cTaste=='w')	
			cTaste=f_schluss(ergebnis,wert1,cTaste);
 
		// Hier wird der Rückwert einer abfang Schleife abgefangen und ans Konzept angepasst.
		else if (cTaste=='a') 
				cTaste=27;
 
			// Hier wird der Rückwert einer abfang Schleife abgefangen und ans Konzept angepasst.
			else if (cTaste=='j') 
				cTaste='n';
 
				// Das ist die letzte Abfang möglichkeit, wenn cTaste weder d,g,n,w,j,a oder Esc ist.
				else if (cTaste != 27)			
					cTaste=f_abfang(cTaste);
 
	}
	// Abbruchbedingung für den Taschenrechner (27 steht in der ASCII-Tabelle für die Esc Taste
	while(cTaste != 27);
};