wieder templates: ein logisches typ/wert rückgabe problem

[otze]

hab mir grad einen artikel über expression templates als einstieg in die metaprogrammierung durchgelesen(wurde mir in einem andren thread empfohlen), und hoffe ihn verstanden zu haben(ziemlich harter tobak und dazu auf englisch :D), also wenn im folgenden ein dicker gedanklicher fehler sein sollte, bitte schlagen

also, fangen wir erstmal mit dem gedankenspiel an:
nehmen wir an, ich habe einen beliebigen mathematischen ausdruck expr(expression).
dieser ausdruck kann eine zahl sein, also expr->zahl.
aber ein ausdruck kann auch ein operator sein:expr->zahl+zahl.
in einem mathematischen ausdruck kann man aber nicht erwarten, dass ein operator nur zahlen als operanden hat, daraus folgt:
expr->expr+expr

nun kommt das programmiertechnische problem:
will man eine templateklasse machen, deren template-parameter so verschachtelt werden können, dass sie-systematisch abgearbeitet-einen mathematischen baum ergeben können, bekommt man ein rückgabetyptechnisches problem:

expr<addition<expr<zahl<int,10> >,expr<zahl<int,20> > > > a;

nehmt euch ruhig ne minute um da durchzublicken
nun das problem: wenn ich nun expr<...>.getValue aufrufe, sollen alle werte die in den templates drinstehen ausgerechnet werden,das problem besteht darin, dass expr<...> nicht weis, welcher rückgabewert zu erwarten ist, ob es nun ein integer, long, float oder double ist,immerhin ist ja dazwischen noch eine ebene über die klasse addition.
weis jemand wie man das umgehen oder lösen kann?
(und nein, ich will das nicht "normal machen" )

[SideWinder]

Wie wärs wenn expr noch einen dritten Template-Parameter bekommt "class Rueck" der den Rückgabetyp bestimmt?

MfG SideWinder

[volkard]

otze schrieb:

weis jemand wie man das umgehen oder lösen kann?

mit traits?

[otze]

traits? was ist das?^^
//edit gefunden, aber das ist nicht die lösung meines problems:

vielleicht hast du schonmal eine mathematische aufgabe in ihren "baum zerlegt, also eine struktur folgender art:

(a+b*c)/d

passender baum:

"/"
                                 /  \
                                /    \
                               +     d
                              / \
                             /   \
                            a    *
                                / \
                               /   \
                               b   c

das problem ist, dass ich zur compilezeit nicht herausbekommen kann, welchen datentyp ich während den einzelnen operationen haben kann.
bei b*c kann es int sein,bei +a kanns wieder float sein, und bei /d dann double, und das war mein problem, da ich so nicht bestimmen kann, was für einen rückgabewert diese funktion hat, das kann ich wenn dann zur ausführungszeit des programms wissen, ausser natürlich, ich kann sofort auf die jeweiligen endpunkte der verschachtelungen zugreifen, und deren typ direkt abfragen,aber das würde selbst wenns möglich wär, eine extrem unperformante schleife ergeben, die bis zur nten ebene des mathematischen baumes vorstoßen müsste.
vielleicht is auch was mit membertemplates dran zu machen, ich bezweifle es aber irgendwie^^

[volkard]

doch, mit traits kann man sagen,
intint=int
intdouble=double
doubleint=double
doubledouble=double

hab sowas wengstens schonmal gesehen. hab aber eine ahnung mehr, wie das implementiert war. spontan fällt mir ein:

template<class A,class B,class OP>
class ResultType{
};
temlate<class X,class OP>
class ResultType<X,X,OP>{
   typedef X VALUE;
};
template<class OP>
class ResulType<int,double,OP>{
   typedef double VALUE;
};
...