Hello,
(I already posted this at comp.lang.c++.moderated, but received no
answers, maybe it is better placed here?):
to implement a little symbolic computation system, dealing with
Polynomials, arbitrary long Integers, symbolic variables, hash tables
and other relevant stuff I set up a certain scheme of classes in the
following form:
A class system of "Types" having as base class
class Expr {
....
ExprRep *rep;
}
and derived classes
Variable: public virtual Expr for variables
RingElem: public virtual Expr for all ring elements
Integer: public RingElem for long integers
Rational: public RingElem for rationals
To every class X of this hierarchy corresponds a class Xrep which gives
its concrete implementation. So the "Types" hierarchy classes X are
"Envelope" classes, the Xrep are "Letter" classes.
So in the above example we have:
ExprRep
VariableRep: public ExprRep
RingElemRep: public ExprRep
IntegerRep: public RingElemRep
RationalRep: public RingElemRep
The functions that apply for a type X are provided in Xrep, sometimes as
virtual functions, for example in RingElemRep, there is
virtual RingElem add(const RingElem& b)
which is repeated and concretized in IntegerRep.
The "type"-classes delegate their functions via overloaded operator->,
that is, for example, Variable contains
VariableRep* getRep () {
return dynamic_cast<VariableRep*>(Expr::getRep()); }
VariableRep* operator-{return getRep(); }
with Expr::getRep() being
ExprRep* getRep() { return rep; };
In general every "type"-class X contains
XRep* getRep () { return dynamic_cast<XRep*>(Expr::getRep()); }
XRep* operator-{return getRep(); }
The advantage of this setup seems to me, that there need not be a fat
interface in ExprRep, offering all functions in all derived classes from
ExprRep.
With this setup I can write
Variable v("x");
Integer i(7);
i->add(i) // ok, calls IntegerRep::add(const RingElem& b)
v->add(i) // error, no add method in VariableRep
Additionally there is in every "type"-class X a pseudo-copy constructor
X(const Expr& e) {rep = dynamic_cast<XRep*>(e.rep);}
(actually there is reference counting added)
This allows type checking and dynamic typing
Variable v("x");
Integer i(7);
Expr ei = i;
Expr ev = v;
f(Integer j) { cout << j; }
f(i) // ok
f(v) // error
(v gets interpreted as Expr, then Integer(const Expr& e) as described
above is tried, but rep of v points to a VariableRep which can not be
dynamic casted to an IntegerRep*).
f(ei) // ok
f(ev) // error
So far so good(?). As I am not that experienced in C++ I would first
appreciate to hear some critique of this approach and second pose a
specific question: As mentioned above there are some functions that
repeat themselves in varied form in every "type"-class, namely
XRep* X::getRep () { return dynamic_cast<XRep*>(Expr::getRep()); }
XRep* X::operator-{return getRep(); }
X::X(const Expr& e) {rep = dynamic_cast<XRep*>(e.rep);}
where X is the "type"-class. Currently I handle this with a #define
macro to save me from typing, but is there a way in C++ to do this
without macros. I tried some schemes with templates and derivation but
it never worked out...
Greetings
Jürgen
--
Jürgen Böhm
www.aviduratas.de
"At a time when so many scholars in the world are calculating, is it not
desirable that some, who can, dream ?" R. Thom
