ich schreibe mir gerade einen kleinen Taschenrechner. Soweit funktioniert das Ding schon ganz gut, doch da sich die Berechnungen in Mathe nicht nur auf Skalare beschränken, möchte ich meinen Taschenrechner auch um Komplexe Zahlen, Vektoren und Matrizen erweitern.

Als Ansatz hatte ich so eine Art Typsystem als Klassenhierachie im Kopf:

class NumericType {
public:
operator+(const NumericType&) = 0;
operator-(const NumericType&) = 0;
//operator...(const NumericType&) = 0;
};

class Scalar : public NumericType {...};
class Complex : public NumericType {...};
class Vector : public NumericType {...};
class Matrix : public NumericType {...};

So könnte ich da dann meine Berechnungen ungefähr so umsetzen:

typedef struct {
NumericType* value;
//...
} Token;

Token GetToken() {...}
// in einer Berechnung zb.

Token CurrentToken;
Result = CurrentToken->Value + GetToken()->Value;

So würde dann für jeden Typ der richtige Operator aufgerufen. Wo ich aber noch nicht ganz sicher bin, wie ich am besten die mathematischen Gesetze (mit den Gesetzen mein ich zb. wenn der User ein Skalar zu einem Vektor addieren will, was ja eigentlich nicht definiert ist) berücksichtige? Innerhalb der Implementationen oder sollte das der Parser schon vorher klären und notfalls eine Exception auslösen?

Ich will einfach mal eure Meinung, Hinweise oder Alternativen zu meinem Ansatz hören...

Besten Danke, MfG

Wenn mich nicht alles täuscht gibt es auch ein Design Pattern, welches die Sache recht gut löst. (So dass Scalar, Complex, etc. nichts voneinander wissen müssen.) Nur hab ich das nie gebraucht, kann dir somit leider auch net sagen, wies aufgebaut is .

Naja vielleicht hilft auch eine einfache Verknüpfungsliste, in der du die verschiedenen Klassen(-namen) reinschreibst, die nicht miteinander kooperieren können. Wenns nur bei bestimmten Operationen Ausnahmen geben soll, hilft noch ein Extra-Flag.