class Token {
public:
    char kind;       
    double value; 
    Token(char ch)    
        :kind(ch), value(0) { }    
    Token(char ch, double val)   
        :kind(ch), value(val) { }
};

class Token_stream {
public:
Token_stream();
Token get();
void putback(Token t);
private:
bool full;
Token buffer;
};

Token_stream::Token_stream()
	:full(false), buffer(0) 
{}
void Token_stream::putback(Token t)
{
	if (full) error("putback(): Zurueckstellen nicht moeglich, Puffer voll");
	buffer= t;
	full = true;
}

Token Token_stream::get()
{
	if(full)
	{
		full = false;
		return buffer;
	}
char ch;
cin >> ch;

switch (ch)
{
    case ';':
	case 'q':
	case '(' : case ')':case '+':case '-':case'*':case'/':case'%':
		return Token(ch);
	case '.':
	case '0': case '1': case '2': case '3' :case '4' : case '5' : case '6': case '7': case '8' : case '9':
		{ cin.putback(ch);
		double val;
		cin >> val;
		return Token('8',val);
		}
	default:
		error("Ungueltiges Token");
}
}

//-----------------------------------------------------------------------------

Token_stream ts;
Token t = ts.get();

//------------------------------------------------------------------------------

Token get_token()    
{
    char ch;
    cin >> ch;    

    switch (ch) {

    case '(': case ')': case '+': case '-': case '*': case '/': 
        return Token(ch);        
    case '.':
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
        {    
            cin.putback(ch);        
            double val;
            cin >> val;              
            return Token('8',val);   
        }
    default:
        error("Ungueltiges Token");
    }
}

//------------------------------------------------------------------------------

double expression();  

//------------------------------------------------------------------------------

double term();     

//------------------------------------------------------------------------------

double primary()    
{
    Token t = get_token();
    switch (t.kind) {
    case '(':    
        {    
            double d = expression();
            t = get_token();
            if (t.kind != ')') error("')' erwartet");
            return d;
        }
    case '8':           
        return t.value; 
    default:
        error("Faktor erwartet");
    }
}
//------------------------------------------------------------------------------

int main()
try {
	double val = 0;
while (cin) { 
Token t = ts.get();
if(t.kind=='q') break;
if(t.kind==';')
	cout <<"=" << val << endl;
else
	ts.putback(t);
	val = expression();
}
    keep_window_open();
}
catch (exception& e) {
    cerr << e.what() << endl;
    keep_window_open();
    return 1;
}
catch (...) {
    cerr << "Ausnahme\n";
    keep_window_open();
    return 2;
}

//------------------------------------------------------------------------------

double expression()
{
    double left = term();      
    Token t = ts.get();   
    while(true) {
		switch(t.kind){
		case '+':
			left+= term();
			t = ts.get;
			break;
		case '-':
		left -= term();
		t = ts.get();
		default:
			ts.putback(t);
			return left;
		}
	}
}
//------------------------------------------------------------------------------

double term()
{
    double left = primary();
    Token t = ts.get();    

    while(true) {
        switch (t.kind) {
        case '*':
            left *= primary();
            t = ts.get();
            break;
        case '/':
            {    
                double d = primary();
                if (d == 0) error("Division durch null");
                left /= d; 
                t = ts.get();
                break;
            }
        default:
			ts.putback(t);
            return left;
        }
    }
}

Ich benutze dazu die vom Lehrbuch vorgegebene Headerdatei:

#ifndef H112
#define H112 201004L

#include<iostream>
#include<fstream>
#include<sstream>
#include<cmath>
#include<cstdlib>
#include<string>
#include<list>
#include<vector>
#include<algorithm>
#include<stdexcept>

//------------------------------------------------------------------------------

#ifdef _MSC_VER
#include <hash_map>
using stdext::hash_map;
#else
#include <ext/hash_map>
using __gnu_cxx::hash_map;

namespace __gnu_cxx {

    template<> struct hash<std::string>
    {
        size_t operator()(const std::string& s) const
        {
            return hash<char*>()(s.c_str());
        }
    };

} // of namespace __gnu_cxx
#endif

//------------------------------------------------------------------------------

#define unordered_map hash_map

//------------------------------------------------------------------------------

typedef long Unicode;

//------------------------------------------------------------------------------

using namespace std;

template<class T> string to_string(const T& t)
{
	ostringstream os;
	os << t;
	return os.str();
}

struct Range_error : out_of_range {	// enhanced vector range error reporting
	int index;
	Range_error(int i) :out_of_range("Range error: "+to_string(i)), index(i) { }
};

// trivially range-checked vector (no iterator checking):
template< class T> struct Vector : public std::vector<T> {
	typedef typename std::vector<T>::size_type size_type;

	Vector() { }
	explicit Vector(size_type n) :std::vector<T>(n) {}
	Vector(size_type n, const T& v) :std::vector<T>(n,v) {}
	template <class I>
	Vector(I first, I last) :std::vector<T>(first,last) {}

	T& operator[](unsigned int i) // rather than return at(i);
	{
		if (i<0||this->size()<=i) throw Range_error(i);
		return std::vector<T>::operator[](i);
	}
	const T& operator[](unsigned int i) const
	{
		if (i<0||this->size()<=i) throw Range_error(i);
		return std::vector<T>::operator[](i);
	}
};

// disgusting macro hack to get a range checked vector:
#define vector Vector

// trivially range-checked string (no iterator checking):
struct String : std::string {

	String() { }
	String(const char* p) :std::string(p) {}
	String(const string& s) :std::string(s) {}
	template<class S> String(S s) :std::string(s) {}
	String(int sz, char val) :std::string(sz,val) {}
	template<class Iter> String(Iter p1, Iter p2) : std::string(p1,p2) { }

	char& operator[](unsigned int i) // rather than return at(i);
	{
		if (i<0||size()<=i) throw Range_error(i);
		return std::string::operator[](i);
	}

	const char& operator[](unsigned int i) const
	{
		if (i<0||size()<=i) throw Range_error(i);
		return std::string::operator[](i);
	}
};

#ifndef _MSC_VER
namespace __gnu_cxx {

    template<> struct hash<String>
    {
        size_t operator()(const String& s) const
        {
            return hash<std::string>()(s);
        }
    };

} // of namespace __gnu_cxx
#endif

struct Exit : runtime_error {
	Exit(): runtime_error("Exit") {}
};

// error() simply disguises throws:
inline void error(const string& s)
{
	throw runtime_error(s);
}

inline void error(const string& s, const string& s2)
{
	error(s+s2);
}

inline void error(const string& s, int i)
{
	ostringstream os;
	os << s <<": " << i;
	error(os.str());
}

#if _MSC_VER<1500
	// disgusting macro hack to get a range checked string:
	#define string String
	// MS C++ 9.0 have a built-in assert for string range check
	// and uses "std::string" in several places so that macro substitution fails
#endif

template<class T> char* as_bytes(T& i)	// needed for binary I/O
{
	void* addr = &i;	// get the address of the first byte
						// of memory used to store the object
	return static_cast<char*>(addr); // treat that memory as bytes
}

inline void keep_window_open()
{
	cin.clear();
	cout << "Please enter a character to exit\n";
	char ch;
	cin >> ch;
	return;
}

inline void keep_window_open(string s)
{
	if (s=="") return;
	cin.clear();
	cin.ignore(120,'\n');
	for (;;) {
		cout << "Please enter " << s << " to exit\n";
		string ss;
		while (cin >> ss && ss!=s)
			cout << "Please enter " << s << " to exit\n";
		return;
	}
}

// error function to be used (only) until error() is introduced in Chapter 5:
inline void simple_error(string s)	// write ``error: s?? and exit program
{
	cerr << "Fehler: " << s << '\n';
	keep_window_open();		// for some Windows environments
	exit(1);
}

// make std::min() and std::max() accessible:
#undef min
#undef max

#include<iomanip>
inline ios_base& general(ios_base& b)	// to augment fixed and scientific
{
	b.setf(ios_base::fmtflags(0),ios_base::floatfield);
	return b;
}

// run-time checked narrowing cast (type conversion):
template<class R, class A> R narrow_cast(const A& a)
{
	R r = R(a);
	if (A(r)!=a) error(string("info loss"));
	return r;
}

inline int randint(int max) { return rand()%max; }

inline int randint(int min, int max) { return randint(max-min)+min; }

inline double sqrt(int x) { return sqrt(double(x)); }	// to match C++0x

#endif

Beim Kompilieren sind jetzt relativ viele Fehler aufgetreten, jedoch reicht mein Kenntisstand nicht dieses zu behen bzw. zu verstehen. Vielleicht könnt ihr mir ja weiterhelfen.

MFG Vezax

Beim Kompilieren sind jetzt relativ viele Fehler aufgetreten, jedoch reicht mein Kenntisstand nicht dieses zu behen bzw. zu verstehen. Vielleicht könnt ihr mir ja weiterhelfen.

MFG Vezax

Und welche waren das ?

[code]1>------ Erstellen gestartet: Projekt: C++ Taschenrechner, Konfiguration: Debug Win32 ------
1> Taschenrechner.cpp
1>c:\users\user\documents\visual studio 2010\projects\c++ taschenrechner\c++ taschenrechner\taschenrechner.cpp(186): error C3867: "Token_stream::get": Dem Funktionsaufruf fehlt die Argumentliste. Verwenden Sie "&Token_stream::get", um einen Zeiger auf den Member zu erstellen.
1>c:\users\user\documents\visual studio 2010\projects\c++ taschenrechner\c++ taschenrechner\taschenrechner.cpp(186): error C2679: Binärer Operator '=': Es konnte kein Operator gefunden werden, der einen rechtsseitigen Operanden vom Typ 'Token (__thiscall Token_stream:: )(void)' akzeptiert (oder keine geeignete Konvertierung möglich)*
1> c:\users\user\documents\visual studio 2010\projects\c++ taschenrechner\c++ taschenrechner\taschenrechner.cpp(37): kann 'Token &Token::operator =(const Token &)' sein
1> bei Anpassung der Argumentliste '(Token, Token (__thiscall Token_stream::* )(void))'
========== Erstellen: 0 erfolgreich, Fehler bei 1, 0 aktuell, 0 übersprungen ==========

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Warum postest du nicht den Code, der die Fehlermeldung liefert? Ein Funktionsaufruf hat immer Klammern, die fehlen an der vom Compiler bemängelten Stelle.

Die Stelle ist übrigens

t = ts.get;

in expression().

Token get_token()    
{
    char ch;
    cin >> ch;    

    switch (ch) {

    case '(': case ')': case '+': case '-': case '*': case '/': 
        return Token(ch);        
    case '.':
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
	case ';': case 'q':
        {    
            cin.putback(ch);        
            double val;
            cin >> val;              
            return Token('8',val);   
        }
    default:
        error("Ungueltiges Token");
    }
}

Versuche ich dieses Programm zu benutzen, schließt sich das Fenster nach der Eingabe von ';' und Enter direkt. ohne den Void aus der Headerdatei aufzurufen.
Mit der Fehlermeldung "ungueltiges Token" welcher in Default aufgerufen werden sollte, Allerdings habe ich doch nun ';' und 'q' eingebunden oder etwa nicht?

Edit: Ich hab es jetzt mehrmals probiert ohne eine Änderung am Code vorzunehmen und siehe da, der Taschenrechner funktioniert ohne Probleme

Edit2: Zu früh gefreut, der Taschenrechner funktioniert nur wenn man am Anfang nur einen Charakter (Zahl) eingibt und diesen ausrechnen lässt, danach sind alle Operationen möglich und auch korrekt. Tut man dies nicht kommen wir wieder zum oben beschrieben Fehler. Woran könnte das Liegen?

Danke auf die Hinweisung bezüglich der Funktion, ich werds mir merken

Oh, das muss ich wohl übersehen haben. Der Code lässt sich jetzt kompilieren. Mir ist auch aufgefallen das die Zeichen ';' und 'q' garnicht als Token eingebunden waren.

Token get_token()    
{
    //...
    switch (ch) {
    /...
	case ';': case 'q':
        {    
            cin.putback(ch);        
            double val;
            cin >> val;              
            return Token('8',val);   
        }
    /...
}

Versuche ich dieses Programm zu benutzen, schließt sich das Fenster nach der Eingabe von ';' und Enter direkt. ohne den Void aus der Headerdatei aufzurufen.
Mit der Fehlermeldung "ungueltiges Token" welcher in Default aufgerufen werden sollte, Allerdings habe ich doch nun ';' und 'q' eingebunden oder etwa nicht?

Ja, schon. Aber warum willst Du ';' und 'q' in einen double einlesen? Das wird schiefgehen und das Zeichen wird im stream verbleiben - was zu unerwarteten Ergebnissen führen wird.