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:

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); }
};

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