Comment appeler une surcharge d'un opérateur basé sur un modèle sans utiliser le mot 'opérateur'?

Question

class RunAround; 
class HopUpAndDown; 
class Sleep; 

template<typename Acts> int doThis(); 
template<> int doThis<RunAround>() { /* run run run.. */ return 3; } 
template<> int doThis<HopUpAndDown>() { /* hop hop hop.. */ return 2; } 
template<> int doThis<Sleep>()  { /* zzz.. */ return -2; } 

struct Results 
{ 
    template<typename Act> int& operator()() 
    { 
     static int result; 
     return result; 
    } 
}; 



int main() 
{ 
    Results results; 
    //results<RunAround>() = doThis<RunAround>(); 
    results.operator()<RunAround>() = doThis<RunAround>(); 
    results.operator()<Sleep>() = doThis<Sleep>(); 
    return 0; 
}; 

Si je supprime le commentaire, le compilateur pense que je fais appel operator() en classe modèle non Results<RunAround> quand je existant veux operator<RunAround>() en classe Results.

Si je veux continuer à utiliser une surcharge d'opérateur au lieu d'un nom normal, suis-je condamné à utiliser la syntaxe terrible sous le commentaire (qui fonctionne)?

Answer 1

La chose la plus confortable est de laisser le travail de déduction argument modèle pour vous:

struct Results { 
    template<typename Act> int& operator()(Act) { /* ... */ } 
}; 

results(RunAround()) = /* ... */;