user bekommt aufgelistet was für rechenmöglichkeiten er hat, und wird um eingabe der entsprechenden zahl (1-10) gebeten..

er gibt zahl ein und dann gehts zu nem switch-case halt rein...
so, nun möchte ich am ende den user fragen ob er noch eine aufgabe rechnen will oder das prog beenden will..also am besten wäre ja ne if-abfrage zb wenn er ja antwortet, die main-funktion oder das prog neugestartet wird...und wenn halt nein das prog beendet wird...

so das wäre das erste...

da ich halt im mom das prog ohne diese abfrage habe, habe ich am ende halt bloß geschrieben "druecken sie eine beliebige taste um das programm zu beenden"
so wollte was neues ausprobieren und gerechnete aufgabe per fstream halt inne txt-datei schreiben und auch die möglichkeit bieten auszulesen...so das prob beim einlesen:

funzt soweit einwandfei, habe es im mom so:

string str_input1, str_input2;
str_input1 = "Bitte geben Sie die erste Zahl ein!";
str_input2 = "Bitte geben Sie die zweite Zahl ein!";
double d_zahl1, d_zahl2;

cout << str_input1 << endl;
 cin >> d_zahl1;
cout << str_input2 << endl;
 cin >> d_zahl2;
cout << "\n" << d_zahl1 << " - " << d_zahl2 << " = " << d_zahl1 - d_zahl2 << " !" << endl;
ofstream Ergebnis("ergebnis.txt");
cout.rdbuf(Ergebnis.rdbuf());
cout << "\n" << d_zahl1 << " - " << d_zahl2 << " = " << d_zahl1 - d_zahl2 << " !" << endl;

jetzt is das prob ja, das er danach mit break; aus dem case rauspringen würde und dann das prog beenden sollte, bloß vorher noch schreiben sollte, "druecken sie eine beliebige taste um das programm zu beenden" wie oben beschrieben...das tut er nun nicht mehr...weiß wer warum?

2.:
er speichert die datei so ab:

<freie zeile>
aufgabe+ergebnis
<freie zeile>

warum schreibt er freie zeilen mit rein?wie verhindere ich das??
und wenn ich halt ne neue aufgabe mache, wird vorhergie schon in der txt vorhandene überschrieben..wie gehts, das er ne neue zeile anfängt???

würd mich über hilfe freuen...cu
Pred

so, nun möchte ich am ende den user fragen ob er noch eine aufgabe rechnen will oder das prog beenden will..also am besten wäre ja ne if-abfrage zb wenn er ja antwortet, die main-funktion oder das prog neugestartet wird...und wenn halt nein das prog beendet wird...

Setz dein Programm in eine do-while-Schleife. Am Ende von der Schleife kommt die if-Abfrage hin, ob man noch mal rechnen will. Der Schleife gibst du den Parameter, dass sie so lange laufen soll, wie ja geantwortet wird.

Pred schrieb:

jetzt is das prob ja, das er danach mit break; aus dem case rauspringen würde und dann das prog beenden sollte, bloß vorher noch schreiben sollte, "druecken sie eine beliebige taste um das programm zu beenden" wie oben beschrieben...das tut er nun nicht mehr...weiß wer warum?

Am besten würdest du mal deinen switch-Block posten, aus deiner Beschreibung werde ich nicht ganz schlau.

Pred schrieb:

warum schreibt er freie zeilen mit rein?wie verhindere ich das??

Er schreibt leere Zeilen rein, weil du '\n' und "endl" verwendest, die beide (u.a.) einen Zeilenumbruch bewirken. Du kannst '\n' weglassen oder aus "endl" "flush" machen.

Pred schrieb:

und wenn ich halt ne neue aufgabe mache, wird vorhergie schon in der txt vorhandene überschrieben..wie gehts, das er ne neue zeile anfängt???

ofstream Ergebnis("ergebnis.txt",ios::app);

/* Author: Maximilian Fink
  Date: 23.11.03
  Description: 
*/
#include <conio.h>
#include <iostream>

using namespace std;
//Globale Variable
double Ergebniss=0;

//Rechenfunktionprototyping
int Rechner(int Zahl1,char Rechenzeichen,int Zahl2);

int main(){

//benötigte Variablen
int Zahl1, Zahl2;
char Rechenzeichen;
char Abbruchzeichen;
bool Abbruchbedingung;
//Schleife
do{

cin >> Zahl1 >> Rechenzeichen >> Zahl2;
//Aufruf der Rechner funktion mit den in den Variablen gespeicherten Parametern
Rechner(Zahl1,Rechenzeichen,Zahl2);

cout << Ergebniss << "\n";
cout << "Zum beenden y drücken zum neustart c\n";
cin >> Abbruchzeichen; 

//Die entscheidung ob das programm weiterläuft(irgendwo ist ein Fehler)
if(Abbruchzeichen=='y'){
Abbruchbedingung=false;
}
else if(Abbruchzeichen=='c'){
Abbruchbedingung=true;
}

else{
Abbruchbedingung=false;
}

}while(Abbruchbedingung==true);

//Ende der Main Funktion
return 0;
};

//Rechner Funktion
int Rechner(int Zahl1,char Rechenzeichen,int Zahl2){

//Analysierung des Rechenzeichens
if(Rechenzeichen=='+'){
Ergebniss=Zahl1+Zahl2;}

else if(Rechenzeichen=='-'){
Ergebniss=Zahl1-Zahl2;}

else if(Rechenzeichen=='*'){
Ergebniss=Zahl1*Zahl2;}

else if(Rechenzeichen=='/'){
Ergebniss=Zahl1/Zahl2;}

else if(Rechenzeichen=='%'){
Ergebniss=Zahl1%Zahl2;
}

else{
cout << "Sie haben kein akzeptiertes Rechenzeichen eingegeben!";
}

//Ende der Rechner Funktion
return 0;
}

Kompiliert unter Devc++ läuft so.

cu max

////////////////////////////////////////////////////////////////////////
//   			Matr.-Nr.:
//
//
//                      extCalculator.ccp
//
////////////////////////////////////////////////////////////////////////
//	Datum: 17.11.2003
//	
//	Beschreibung des Programms:
//
//	
//	Funktion:
//    Kleiner Taschenrechner zum berechnen der Operationen + - * / ! ^
//
//	Aufbau:	
//    while-Schleife steuert den Verlauf
//    Auswertung der Eingabe durch eine switsch-Auswertung
//	
//	Benutzung:
//	  Eingabe des Operators und des Operanden
//    Beenden mit <e>, Löschen mit <c>
//
//
/////////////////////////////////////////////////////////////////////////
#include <iostream>
using namespace std;

const int OVERFLOW = -1;

void druckEingabeHilfe();
int fakultaet(int n);
bool ganzZahl(double n);
double potenz(double a,int n);

void main()
{

  double Eingabe = 0.0, Speicher = 0.0;
  char Operation = 'a';

  druckEingabeHilfe();

  cout << Speicher;

  while(Operation != 'e')
  { 
	cin >> Operation;

	switch(Operation)
	{
	  case '+':
		  {
			cin >> Eingabe;
			Speicher = Speicher + Eingabe;
			cout << Speicher;
		  }
		  break;

	  case '-':
		  {
			cin >> Eingabe;
			Speicher = Speicher - Eingabe;
			cout << Speicher;
		  }
		  break;

	  case '*':
		  {
			cin >> Eingabe;
			Speicher = Speicher * Eingabe;
			cout << Speicher;
		  }
		  break;

	  case '/':
		  {
			cin >> Eingabe;

			if(Eingabe != 0)
			{
			  Speicher = Speicher / Eingabe;
			  cout << Speicher;
			}
			else
			{
			  cout << "Division durch 0 ist verboten!\n"
			       << Speicher;
			}
		  }
		  break;

	  case '!':
		  {
		    if(Speicher >=0)
			{
			  double Zwischen = Speicher;

			  if(ganzZahl(Speicher))
			  {
			    Speicher = fakultaet(int(Speicher));

			    if(Speicher == OVERFLOW)
			    {
				  cout << "OVERFLOW\n";
				  Speicher = Zwischen;
			    }
			  }
			  else
			    cout << "Keine ganze Zahl\n";
			}
			else
			  cout << "kein negativer Wert!" << endl;

		    cout << Speicher;
		  }
		  break;

	  case '^':
		  { 
		    cin >> Eingabe;

			if(ganzZahl(Eingabe))			
		      Speicher = potenz(Speicher,int(Eingabe));
			else
			  cout << "Nur ganze Zahlen als Exponent!\n";

			cout << Speicher;
		  }
		  break;

	  case 'c':
		  {
			Speicher = 0.0;
			cout << Speicher;
		  }
		  break;

	  case 'e':
		  break;

	  default:
		  {
		    cout << Operation << "--> Falscher Operator!\n";
		    cout << Speicher;			
		  }
		  break;
	}
  }
}

//druckEingabeHilfe/////////////////////////////////////////////
//
// Unterprogramm zur Ausgabe der Eingabehilfe im Hauptprogramm
//
////////////////////////////////////////////////////////////////

void druckEingabeHilfe()
{
  cout << "Kleiner Taschenrechner!\n"
	   << "Erlaubte Operationen: + - * / ! ^\n"
	   << "Abbruch mit <e>, Loeschen mit <c>\n" << endl;
}

//fakultaet/////////////////////////////////////////////////////
//
// berechnet die fakultaet einer Zahl n
// gibt die fakultaet zurück
// 
// bei SpeicherOverflow wird die Overflow-Constante zurückgegeben
//
////////////////////////////////////////////////////////////////
int fakultaet(int n)
{
  int Zahl = n;
  int Test = 0;
  bool Speicher = false;

  if(n!=0)
  {
    for(n =n-1 ;n>0 ; n--)
	{
	  Test = Zahl;
	  Zahl = Zahl * n;

	  if(Test != (Zahl/n))
	   Speicher = true;
	}

	if(Speicher)
	  return OVERFLOW;
	else
	  return Zahl;	
  }
  else
  {
    Zahl = 1;
    return Zahl;
  }
}

//ganzZahl/////////////////////////////////////////////////////
//
//Eingegebene Zahl = integer: Return true
//Eingegebene Zahl != integer: Return false
//
////////////////////////////////////////////////////////////////

bool ganzZahl(double n)
{
  double test = n;

  return (test == (double(int(n))));
}

///potenz////////////////////////////////////////////////////////
//
// berechnet Potenzen
// a => Basis
// n => Exponent
//
// nur ganze Zahlen für Exponent!
//
/////////////////////////////////////////////////////////////////

double potenz(double a,int n)
{
	double Zahl = a;
        int i = 0;

	if(n > 0)
	{ 
	  for(i = n-1;i > 0; i--)
		a = a * Zahl;
	}
	if(n == 0)
	  a = 1;

	if(a!= 0 && n < 0)
	{
	  for(i = (-1)*n-1 ;i > 0; i--)
		a = a * Zahl;

	a = 1/a;
	}
	return a;
}