durch probieren hab ich unten dargestellte Template-Operator-Kombination hinbekommen. Weiß jemand, ob das nur ein Compiler-abhängiges Verhalten widerspiegelt oder ob das immer so sein muss? Wenn letzteres, warum?
(Knackpunkt: Beim 2. Operator könnte es sich um eine Re-Definition des 1. handeln)

Hier Das Beispielprogramm:

#include <iostream>
using namespace std;

class AA
{
private:
public:
typedef bool OP_AA ;
int i;
};

class BB
{
private:
public:
typedef bool OP_BB ;

int i;
};

template <class Typ>
typename Typ::OP_AA operator>(const Typ& _s, const Typ& _r)
{
cout<<"In OP_AA "<<endl;
return true;
}

template <class Typ>
typename Typ::OP_BB operator>(const Typ& _s, const Typ& _r)
{
cout<<"In OP_BB "<<endl;
return false;
}

int main(int argc, char* argv[], char* env[])
{

AA aa_x, aa_y;
BB bb_x, bb_y;
bool frage = true;

frage = (aa_x > aa_y);
cout<<"frage (aa_x > aa_y) "<<frage<<endl;

frage = (bb_x > bb_y);
cout<<"frage (bb_x > bb_y) "<<frage<<endl;

return 0;
}

Liefert die Ausgabe:
###>
In OP_AA
frage (aa_x > aa_y) 1
In OP_BB
frage (bb_x > bb_y) 0
###>

In deinem Beispiel:

Für aa_x > aa_y existieren mindestens zwei Überladungen (deine beiden Templates). Die erste wird zu:

AA::OP_AA operator>(const AA& _s, const AA& _r);

die zweite zu:

AA::OP_BB operator>(const AA& _s, const AA& _r);

Da AA keinen Typ namens OP_BB besitzt, wird die zweite Überladung ignoriert.

Was ich im Zusammenhang mit SFINAE dann aber nicht verstehe ist, warum die folgende Konstruktion nicht klappt (s.u.).

Hier bekomme ich dann die Fehlermeldung (beim 2. Operator-Template mit Bezug auf's erste):

Error 174: "mytest.cpp", line 248 # Function redefinition; previously defined as "bool operator >(const
 #1 &,const #1 &)" at ["mytest.cpp", line 241].
    bool operator>(const Typ& _s, const Typ& _r)

Auch Veruche, OP_xx in "aktiveren" Code zu stecken, klappten nicht. Ist das dann ein Kompiler-Fehler oder bezieht sich SFINAE nur auf den Rückgabewert?

class AA
{
private:

public:

   typedef int OP_AA ;
   int i;
};

class BB
{
private:

public:

   typedef int OP_BB ;
   int i;
};

template <class Typ>    
bool operator>(const Typ& _s, const Typ& _r) 
{
   return true; //(_r < _s);
   typename Typ::OP_AA dummy;
}

template <class Typ>    
bool operator>(const Typ& _s, const Typ& _r) 
{
   return true; //(_r < _s);
   typename Typ::OP_BB dummy;
}

int main(int argc, char* argv[], char* env[])
{

    AA aa_a,aa_b;
    bool frage = true;

    frage = (aa_a > aa_b);
    cout<<"frage "<<frage<<endl;

    return 0;
}