Implizite Templateparameter, wann geht das und wann nicht?

[Karl R]

Hallo,
ich wundere mich etwas darüber, wann der Compiler klug genug ist, sich Templateparameter implizit zu erschließen und wann nicht. Besonders paradox sieht das ganze aus, wenn man ein Template indirekt benutzt:

template<typename A, typename B> class example{
private:
  A aa;
  B bb;
public:
  example(const A & p1, const B & p2): aa(p1), bb(p2) {}
  static double direct_static_member(const A& a, const B& b){
    return a*b;
  }
};

template< typename A ,typename B> inline double indirect_static_member(const A& a, const B& b){
  return example<A,B>::direct_static_member(a,b);
}

template< typename A ,typename B> inline example<A,B> indirect_constructor(const A& a, const B& b){
  return example<A,B>(a,b);
}

int main(){
  int a(1);
  double b(2.);

  indirect_static_member(a,b);                    // Gültiger Ausdruck, wird compiliert
  example::direct(a,b);                           // Ungültig, muss Typen explizit angeben...
  example<int,double>::direct_static_member(a,b); // ...so wie hier

  indirect_constructor(a,b);                      // Indirekt kann man den Konstruktor aufrufen
  example(a,b);                                   // Direkt wiederum nicht
  example<int,double>(a,b);                       // So ist es richtig
}

Offensichtlich werden im Fall von template-Funktionen die Parameter implizit angenommen und im Fall von Klassen nicht. Gibt es da einen tieferliegenden Grund für oder ist das einfach nur der C++-Standard? Oder ist einfach meine Syntax falsch und es gibt doch die Möglichkeit bei Klassen die Typen implizit anzugeben?

[pumuckl]

Ganz einfach: bei Funktionen weiß er ja bei den übergebenen Parametern, welchen Typ die haben und kann die entsprechenden Typen daraus herleiten. Bei Klassen geht das nicht. Die Rückgabetypen von Funktionen kann er z.B. auch nicht herleiten.