templates mit zirkulärer Abhängigkeit

peterchen

Ich versuch' grad folgendes:

Ich habe einen Satz von Funktoren

struct isX { bool operator()(char c) { ... }  }
struct isY { bool operator()(char c) { ... }  }

Die will ich mit &&, || und ! zu neuen Funktoren zusammenbauen:

template <typename A, typename B>
struct is_AND
{
   A a; B b;
   is_AND(A a_, B b_) : a(a_), b(b_) {}
   bool operator()(char c) { return a(c) && b(c); }
}

Soweit funktioniert noch alles.
Mein Problem:

Wie definiere ich jetzt die überladenen Operatoren?
Ich hab folgendes versucht:

template <typename Derived>
struct is_Logical
{
   is_NOT<Derived> operator!() 
   { return is_NOT<Derived>( *static_cast<Derived *>(this)); }

   template <typename RHS>
   is_AND<Derived, RHS> operator && (RHS rhs) const 
   { return is_AND<Derived, RHS>(*static_cast<Derived *>(this), rhs); }

   template <typename RHS>
   is_OR<Derived, RHS> operator || (RHS rhs) 
   { return is_OR<Derived, RHS>(*static_cast<Derived *>(this), rhs); }
};

und leite die isX davon ab:

struct isX : public is_Logical<isX>
{
  bool operator isX()(char c) { ... }
}

Das klappt zwar auf der ersten Stufe ( (isX() && isY() ) - aber dem Ergebnis is_AND<isX, isY> fehlen natürlich die operatoren, also z.B. (!isX() && !isY()) funktioniert nicht.

Wie pack' ich die da rein?

:grübel:

.filmor

Hast du schon versucht, is_AND von isLogical (btw, ziemlich verwirrende Namen) abzuleiten? Vorwärtsdeklarationen gibts auch für Templates:

template <typename Derived>
struct isLogical;

template <typename A, typename B>
struct is_AND : public isLogical<is_AND<A,B> >
{
   A a; B b;
   is_AND(A a_, B b_) : a(a_), b(b_) {}
   bool operator()(char c) { return a(c) && b(c); }
};

peterchen

klappt
Hatte ich gar nicht erst versucht, weil forward für eine "normale" Basisklasse ja nicht reicht. Danke!

btw, ziemlich verwirrende Namen

Sorry, das origonal ist noch schlimmer War halt so 'ne fixe Idee, ich wollte aber erst aufräumen wenn ich es wirklich zum laufen bekkomme