Meine Ansatz war das ganze in einen Parsebaum zu laden und diesen zu bearbeiten. In etwa wie folgendermaßen:

class ExprBase{};
class Sum:public ExprBase{ExprBase*a,b};
class Product:public ExprBase{ExprBase*a,b};
class XEvoc:public ExprBase{};
class Num:public ExprBase{int num};

So nun stellt sich die Frage wie ich den Parsebaum anfassen soll. Nach einiger Suche im Internet kam ich auf folgenden Link. Ich hab dies auf diese Weise implementiert allerdigns war alles anderes als zufrieden mit der Lösung. Der Code der zum Beispiel nötig war um einfach heraus zu finden ob ein Ausdruck von x abhängt oder nicht war einfach erschlagend. Das ständige herumgeschlage mit Visitorobjekten war auch lässtig und erschien mir alles anders als intutive.

struct DependsOnX:public Visitor{
  DependsOnX(){result = false;}
  void visit(Product*){a->visit_by(this); b->visit_by(this);}
  void visit(Sum*){a->visit_by(this); b->visit_by(this);}
  void visit(Number*){}
  void visit(XEvoc*){result = true;}
  bool result;
};
//...
DependsOnX vistor;
expr->visit_by(visitor);
if(visitor.result){...}

Ich hab mich danach entschieden ganz einfach dynamic_cast und eine if else Kaskade zu nehmen. Erstaunlicherweise ging dies recht gut und bis auf das lässtige Gecasts auch ansonsten recht intuive. Desweiteren entfällt die ganze Visitor Hierarchie was das ganz auch einfacher macht. Es wurde sogar möglich eine Hierarchie zwischen den Operationen auszunutzen.

class ExprBase{};
class BinOp:ExprBase{ExprBase*a,*b};
class Sum:public BinOp{};
class Product:public BinOp{};
class XEvoc:public ExprBase{};
class Num:public ExprBase{int num};

bool depends_on_x(ExprBase*expr){
  if(BinOp*op = dynamic_cast<BinOp*>(expr))
    // Folgende Zeile wäre beim Visitorpattern doppelt vorhanden.
    return depends_on_x(op->a) || depends_on_x(op->b); 
  else if(dynamic_cast<XEvoc*>(expr))
    return true;
  return false;
}
//...
if(depends_on_x(expr)){...}

Nachdem ich mir ein wenig des Kopf über das Visitorpattern gemacht habe bin ich zum Schluss gekommen, dass es keine Vorteile gegenüber dynamic_cast hat sogar ein paar kleine Nachteile.

Hab ich den Zweck dieses Pattern nicht verstanden?

Btw: Hast du dir mal das Interpreter-Pattern angeschaut?