Ich soll sowas wie einen Taschenrechner programmieren.

Hier mein Code:

#include<iostream>
using namespace std;

int main()
{
char op;
int zahl1, zahl2, erg;

cout << "Zahl 1 eingeben: ";
cin >> zahl1;

cout << endl << "Operator eingeben (moeglicher Operator: +, -, *, /, %): ";
cin >> op;

cout << endl << "Zahl 2 eingeben: ";
cin >> zahl2;

switch (op)
{
case 43:
     cout << "Sie befinden sich in Addition" << endl;
     erg = zahl1 + zahl2;
     cout << "Ergebnis der Addition: " << erg;
     break;

case 45:
     cout << "Sie befinden sich in Subtraktion" << endl;
     erg = zahl1 - zahl2;
     cout << "Ergebnis der Subtraktion: " << erg;
     break;

case 42:
     cout << "Sie befinden sich in Multiplikation" << endl;
     erg = zahl1 * zahl2;
     cout << "Ergebnis der Multiplikation: " << erg;
     break;

case 47:
     cout << "Sie befinden sich in Division" << endl;
     erg = zahl1 / zahl2;
     cout << "Ergebnis der Division: " << erg;
     break;

case 37:
     cout << "Sie befinden sich in Modulo" << endl;
     erg = zahl1 % zahl2;
     cout << "Ergebnis von Modulo: " << erg;
     break;

default: 
        cout << "Ende";
        break;
}

system("pause");
return 0;   
}

Nun möchte ich, dass ich nach der ersten Berechnung von einem der cases wiederholt einen Operator eingeben bzw. mit einem q das Programm beenden kann. Falls man eine Operator eingegeben hat soll man noch eine weitere Zahl eingeben können. Nach dieser Eingabe der Zahl soll nun wiederholt das richtige Ergebnis angezeigt werden. Danach sollen wiederholt eingaben möglich sein und zwar bei der Eingabe des Operators...

Könnt ihr mir helfen?

#include <iostream>
#include <map>
#include <boost/array.hpp>
#include <boost/tr1/functional.hpp>

template<typename T>
class calculator {
  int valnr;
  bool read_op(char& c) {
    std::cout << "Operator eingeben (moeglicher Operator: +, -, *, /): ";
    std::cin >> c; return ops.find(c)!=ops.end(); }
  T read_value() {
    std::cout << "Zahl "<< ++valnr << " eingeben: ";
    T val; while (!(std::cin >> val)); return val; }
  std::map<T, std::tr1::function<T(T,T)> > ops;
public:
  calculator() : valnr(0) {
    ops['+'] = std::plus      <T>();
    ops['-'] = std::minus     <T>();
    ops['*'] = std::multiplies<T>();
    ops['/'] = std::divides   <T>();
  }
  T calc() {
    T a=read_value(); char op; while(!read_op(op)); T b=read_value();
    return ops[op](a, b);
  }
  bool recalc(T& value) {
    char op; if (!read_op(op)) return false;
    T a=read_value(); value=ops[op](value, a); return true;
 }
};
template<typename T> void calc()
{
  calculator<T> c; T value(c.calc());
  do std::cout << "Ergebnis: " << value << std::endl;
  while (c.recalc(value));
}

template<typename InputIterator>
InputIterator prompt_pair(InputIterator first, InputIterator last, int firstnum=0)
{
  InputIterator it = first; int nr;
  for (int i=firstnum; it!=last; it++,i++)
    std::cout << '[' << i << "] für " << it->first << std::endl;
  while (!(std::cin >> nr && nr-firstnum>=0 && nr-firstnum<last-first));
  std::cout << "Auswahl: " << nr << std::endl;
  std::advance(first, nr-firstnum);
  return first;
}

int main()
{
  boost::array<std::pair<const char*, std::tr1::function<void()> >, 4> choices =
    { { { "Ganzzahlen",                   &calc<int>        },
        { "Gleitkommazahlen",             &calc<float>      },
        { "Genaue Gleitkommazahlen",      &calc<double>     },
        { "Sehr genaue Gleitkommazahlen", &calc<long double>} } };
  std::cout << "Welcher Datentyp?" << std::endl;
  prompt_pair(choices.begin(), choices.end())->second();
}

für Wiederholung benötigst du Schleifen. Es gibt die do-while- / while- / und for-Schleife. Diese solltest du dir einaml anschauen.

mfg dweb

Im C Forum habe ich mal sowas ähnliches gepostet:

#include <iostream>
#include <map>
#include <boost/array.hpp>
#include <boost/tr1/functional.hpp>

template<typename T>
class calculator {
  int valnr;
  bool read_op(char& c) {
    std::cout << "Operator eingeben (moeglicher Operator: +, -, *, /): ";
    std::cin >> c; return ops.find(c)!=ops.end(); }
  T read_value() {
    std::cout << "Zahl "<< ++valnr << " eingeben: ";
    T val; while (!(std::cin >> val)); return val; }
  std::map<T, std::tr1::function<T(T,T)> > ops;
public:
  calculator() : valnr(0) {
    ops['+'] = std::plus      <T>();
    ops['-'] = std::minus     <T>();
    ops['*'] = std::multiplies<T>();
    ops['/'] = std::divides   <T>();
  }
  T calc() {
    T a=read_value(); char op; while(!read_op(op)); T b=read_value();
    return ops[op](a, b);
  }
  bool recalc(T& value) {
    char op; if (!read_op(op)) return false;
    T a=read_value(); value=ops[op](value, a); return true;
 }
};
template<typename T> void calc()
{
  calculator<T> c; T value(c.calc());
  do std::cout << "Ergebnis: " << value << std::endl;
  while (c.recalc(value));
}

template<typename InputIterator>
InputIterator prompt_pair(InputIterator first, InputIterator last, int firstnum=0)
{
  InputIterator it = first; int nr;
  for (int i=firstnum; it!=last; it++,i++)
    std::cout << '[' << i << "] für " << it->first << std::endl;
  while (!(std::cin >> nr && nr-firstnum>=0 && nr-firstnum<last-first));
  std::cout << "Auswahl: " << nr << std::endl;
  std::advance(first, nr-firstnum);
  return first;
}

int main()
{
  boost::array<std::pair<const char*, std::tr1::function<void()> >, 4> choices =
    { { { "Ganzzahlen",                   &calc<int>        },
        { "Gleitkommazahlen",             &calc<float>      },
        { "Genaue Gleitkommazahlen",      &calc<double>     },
        { "Sehr genaue Gleitkommazahlen", &calc<long double>} } };
  std::cout << "Welcher Datentyp?" << std::endl;
  prompt_pair(choices.begin(), choices.end())->second();
}

Hat nichts mit der Frage zu tun, sondern ist nur eine Übung zu Funktionszeigern und Templates.

Vllt. wenn du deine Anweisungen per Hand 30 mal hinklatschst ...
Von wem/wo kommt die Aufgabenstellung?

Ich soll laut Aufgabenstellung aber keine Schleifen benutzen. Kann mir aber auch nicht vorstellen wie das dann gehen soll

Dann mal bitte den genauen Wortlaut der Aufgabe.

Ich soll laut Aufgabenstellung aber keine Schleifen benutzen. Kann mir aber auch nicht vorstellen wie das dann gehen soll

Dann baust du dir halt Schleifen mit einem goto nach.

Oder du verwendest, falls das bei dir eine Übung zu Funktionszeigern und Templates ist, die Alternative.

Implementieren Sie einen einfachen Taschenrechner. Der Taschenrechner erwartet Eingaben
von ganzen Zahlen und Operatoren (+, -, *, /, und berechnet jeweils das Ergebnis der
eingegebenen Rechnung, ohne jedoch Punkt-vor-Strich-Rechnung zu berücksichtigen. Die
Operatoren haben die aus C bekannte Semantik. Folgendes Eingabeschema soll der Benutzer
ausführen können:
1. Die erste Eingabe muss eine Zahl sein.
2. Die zweite Eingabe muss ein Operator (siehe oben) oder das Zeichen ‘q‘ für „quit“ sein.
3. Die dritte Eingabe muss eine Zahl sein.
4. Nach der dritten Eingabe wird das Ergebnis der bisherigen Eingabe angezeigt und weitere Eingaben dürfen folgen.
5. Die nächste Eingabe muss ein Operator oder ‘q‘ sein.
6. Die nächste Eingabe muss eine Zahl sein.
7. Nach der Eingabe in Schritt 6. wird das Ergebnis der bisherigen Eingabe angezeigt
und weitere Eingaben dürfen folgen. Hierzu wiederhole ab Schritt 5.
Die Eingabe von ‘q‘ anstelle eines Operators beendet das Programm. Vorher geben Sie jedoch bitte noch das Endergebnis der Rechnung aus.

Verwenden Sie zur Auswertung des Operators bitte eine switch-Anweisung.

EDIT: Goto-Sprünge ist schlechter Stil welchen unser Prof ein paar mal erwähnt und somit mit Sicherheit goto auf Flach fällt

Ich hab das so verstanden, dass sich der Satz auf die ganze Aufgabe bezieht...

Das Auswerten der Operatoren mit switch Anweisung ist ja logisch.
Das hat aber mit dem Rest des Programmes wenig zu tun.

Viel Spaß beim Lösen

(vv signatur gucken vv)

Es wäre auf jeden Fall sinnvoll das switch zeug in eine funktion (zB calc()) zu unterteilen. Ich hab mir es irgendwie angewöhnt alles außerhalb von main() und sogar außerhalb von main.cpp zu schreiben. So habe ich in main() zB nur: MeinKern *kern = new MeinKern(); kern->start(); . Ich wies, das ist komisch...

Das wird noch.

Ihr kennt ja jetzt meine Aufgabe. Ich hab aber trotzdem irgendwie Probleme mit dem Verständnis der Aufgabe. Das liest sich für micht so, dass wenn Schritt 4 (also das Anzeigen des Ergebnisses) vorbei ist dann noch weitere Eingaben (ich find das sehr ungenau angegeben... was sind diese weiteren Eingaben?) machen darf. Das ist mein erstes Problem. Gut man darf weitere Eingaben MUSS aber anscheinend nicht. Dann geht's weiter bei Schritt 5. Der ist klar. Schritt 6 ist mir unklar. Eingabe einer Zahl. Wieder so ungenau. Welche Zahl meint er denn jetzt? Die erste oder die zweite? Vor allem die Eingabe einer Zahl macht doch nicht so viel Sinn, da ich ja dann bei der nächsten Rechenoperation die neue eingegebene Zahl mit der alten Zahl von ganz von Anfang mit dem neuen Operator verrechne... Schritt 7 ist klar, ich soll einfach wieder holen. Meine wahrscheinlich noch fehlerhaftes Programm seht ihr unten:

#include<iostream>
using namespace std;

int main()
{
char op;
int zahl1, zahl2, wzahl, erg, quit;

cout << "Zahl 1 eingeben: ";
cin >> zahl1;

do
{
cout << endl << "Operator eingeben (moeglicher Operator: +, -, *, / oder %): ";
cin >> op;

cout << endl << "Zahl 2 eingeben: ";
cin >> zahl2;

switch (op)
{
case 43:
     cout << "Sie befinden sich in Addition" << endl;
     erg = zahl1 + zahl2;
     cout << "Ergebnis der Addition: " << erg << endl;
     break;

case 45:
     cout << "Sie befinden sich in Subtraktion" << endl;
     erg = zahl1 - zahl2;
     cout << "Ergebnis der Subtraktion: " << erg << endl;
     break;

case 42:
     cout << "Sie befinden sich in Multiplikation" << endl;
     erg = zahl1 * zahl2;
     cout << "Ergebnis der Multiplikation: " << erg << endl;
     break;

case 47:
     cout << "Sie befinden sich in Division" << endl << endl;
     erg = zahl1 / zahl2;
     cout << "Ergebnis der Division: " << erg << endl;
     break;

case 37:
     cout << "Sie befinden sich in Modulo" << endl << endl;
     erg = zahl1 % zahl2;
     cout << "Ergebnis von Modulo: " << erg << endl;
     break;

default:
        cout << "Auf wiedersehen!" << endl;
        break;
}
}while(op != 113);

system("pause");
return 0;   
}

Wie seht ihr die Aufgabe? Ist die Aufgabe ungenau gestellt, oder bin ich einfach zu blöd/dumm/unerfahren oder für die Informatik nicht geeignet um das kapieren?

Danke!

Schreib statt

case 42

lieber

case '*'

damit sofort klar ist das du ein char vergleichen möchtest und nicht einen int, zudem muss man nicht die ascii-Zeichen raten.

#include<iostream>
using namespace std;

int main()
{
char op;
int zahl1, zahl2, erg, quit;

cout << "Zahl 1 eingeben: ";
cin >> zahl1;

do
{
cout << endl << "Operator eingeben (moeglicher Operator: +, -, *, / oder %): ";
cin >> op;

cout << endl << "Zahl 2 eingeben: ";
cin >> zahl2;

switch (op)
{
case '+':
     cout << "Sie befinden sich in Addition" << endl;
     erg = zahl1 + zahl2;
     zahl1 = erg;
     cout << "Ergebnis der Addition: " << erg << endl;
     break;

case '-':
     cout << "Sie befinden sich in Subtraktion" << endl;
     erg = zahl1 - zahl2;
     zahl1 = erg;
     cout << "Ergebnis der Subtraktion: " << erg << endl;
     break;

case '*':
     cout << "Sie befinden sich in Multiplikation" << endl;
     erg = zahl1 * zahl2;
     zahl1 = erg;
     cout << "Ergebnis der Multiplikation: " << erg << endl;
     break;

case '/':
     cout << "Sie befinden sich in Division" << endl << endl;
     erg = zahl1 / zahl2;
     zahl1 = erg;
     cout << "Ergebnis der Division: " << erg << endl;
     break;

case '%':
     cout << "Sie befinden sich in Modulo" << endl << endl;
     erg = zahl1 % zahl2;
     zahl1 = erg;
     cout << "Ergebnis von Modulo: " << erg << endl;
     break;

default:
        cout << "Auf wiedersehen!" << endl;
        break;
}
}while(op != 'q');

system("pause");
return 0;   
}

Hier der neue Code:

#include<iostream>
using namespace std;

int main()
{
char op;
int zahl1, zahl2, erg, quit;

cout << "Zahl 1 eingeben: ";
cin >> zahl1;

do
{
cout << endl << "Operator eingeben (moeglicher Operator: +, -, *, /, % oder q fuer Quit): ";
cin >> op;

switch(op)
{
case '+':
     cout << endl << "Sie befinden sich in Addition" << endl;
     cout << endl << "Zahl 2 eingeben: ";
     cin >> zahl2;
     erg = zahl1 + zahl2;
     zahl1 = erg;
     cout << "Ergebnis der Addition: " << erg << endl;
     break;

case '-':
     cout << endl << "Sie befinden sich in Subtraktion" << endl;
     cout << endl << "Zahl 2 eingeben: ";
     cin >> zahl2;
     erg = zahl1 - zahl2;
     zahl1 = erg;
     cout << "Ergebnis der Subtraktion: " << erg << endl;
     break;

case '*':
     cout << endl << "Sie befinden sich in Multiplikation" << endl;
     cout << endl << "Zahl 2 eingeben: ";
     cin >> zahl2;
     erg = zahl1 * zahl2;
     zahl1 = erg;
     cout << "Ergebnis der Multiplikation: " << erg << endl;
     break;

case '/':
     cout << endl << "Sie befinden sich in Division" << endl << endl;
     cout << endl << "Zahl 2 eingeben: ";
     cin >> zahl2;
     erg = zahl1 / zahl2;
     zahl1 = erg;
     cout << "Ergebnis der Division: " << erg << endl;
     break;

case '%':
     cout << endl << "Sie befinden sich in Modulo" << endl << endl;
     cout << endl << "Zahl 2 eingeben: ";
     cin >> zahl2;
     erg = zahl1 % zahl2;
     zahl1 = erg;
     cout << "Ergebnis von Modulo: " << erg << endl;
     break;

default:
        cout << endl << "Auf wiedersehen!" << endl;
        break;
}
}while(op != 'q');

system("pause");
return 0;   
}

Die Variable quit ist überflüssig und Einrückungen könnten noch optimiert werden.