Interpreter Entwurf

leo aka qsch

Ich schreibe momentan an einem Formelinterpreter, dieser soll folgende Funktionen unterstuetzen
- alle Grundrechenoperatoren (+,-,*,/)
- die 4 Winkelfunktionen (sin, cos, tan, cotan)
- er soll auch einfach erweiterbar sein zb (exponenten, log, usw..)

zB soll er folgenden Ausdruck auswerten koennen

$var1 = 3.3
  $var2 = 7

  f := (4 + 3) - $var1 + cos($var2)

momentan verfolge ich diesen Ansatz
ich habe eine abstrakte Ausdrucks Klasse die mir die Schnittstelle fuer meine Ausdrucksunterklassen wie zB: +, -, sin Ausdruck bereitstellt und die dem User eine interpretierte Formel liefern soll

template <class T>
	class Expression
	{
	public:
		typedef Expression<T> ExpressionBase;

	public:
		Expression();
		virtual ~Expression();

		virtual Expression& interpret() = 0;
	};

	template <class T>
	class ValueExpression : public Expression<T>
	{
	public:
		ValueExpression(T& val) : _value(val) { }
		virtual ~ValueExpression();

		virtual ExpressionBase& interpret() { return new ValueExpression(_value); }

	private:
		T _value;
	};

	template <class T>
	class PlusExpression : public Expression<T>
	{
	public:
		PlusExpression(ExpressionBase& left, ExpressionBase& right)
			: _pleft(left), _pright(right) { }
		virtual ~PlusExpression() { }

		virtual ExpressionBase& interpret() { return new ExpressionBase(_pleft + _pright); }

	private:
		ExpressionBase * _pleft;
		ExpressionBase * _pright;
	};

was haltet ihr von diesem Ansatz.. ich steh momentan auf der Leitung und waere fuer ein paar Denkanstoeße sehr dankbar, vielleicht kennt auch jemand einen einfachen Interpreter dem ich mir anschaun koennte

mfg leo

leo aka qsch

bitte um Hilfe

leo

Panke

Bitte kommentier mal deinen Ansatz, steige da nicht ganz durch.
(Nicht, dass ich dir danach unbedingt helfen könnte ..)

.filmor

Also bei Interpretern wie diesem denke ich an Spirit. Mit dem ginge so etwas (zumindest prinzipiell ;)) deutlich einfacher.

Deinen Ansatz verstehe ich übrigens auch nicht so richtig. Beispielsweise frage ich mich, wieso du Zeiger auf dynamischen Speicher als Referenzen auf diesen zurückgibts. Das schreit doch eigentlich nach Speicherleck.

Und das ExpressionBase-Typedef funktioniert doch afaik nur, wenn in der abgeleiteten Klasse dann

using Expression<T>::ExpressionBase;

steht, was ja wiederum länger als

typedef Expression<T> ExpressionBase;

ist.

Außerdem bin ich mir noch im Unklaren über den Template-Parameter T. Wieso ist nur EIN Typ erlaubt? Wenn du an double gedacht hast, hättest du das auch direkt schreiben können. T=int u.a. ist doch eigentlich auch unsinnig, zumindest in dieser Struktur, die nur einen Typ für den Gesamtausdruck zulässt.