Appel de surcharge de template C++

Question

J'essaye d'implémenter un modèle d'exécution qui prend n'importe quelle fonction et l'exécute avec ses propres conditions/préparations. Indépendamment de ce qui est une chose utile à faire, cela ne fonctionne tout simplement pas. Il semble que je ne puisse pas accéder à la surcharge du template de la fonction "Execute" (appelée dans "main").

Spécifiquement: Pourquoi ne puis-je pas appeler la fonction de modèle surchargé de Execute?

Voici le programme complet:

#include "stdafx.h" 
#include <functional> 

class TransparentFunctionWrapper 
{ 
public: 
    virtual void Execute(std::function<void()> executeFunction) = 0; 

    template<class C> 
    C Execute(std::function<C(void)> executeFunction) // template-overload of the abstract function which will implicitly call it 
    { 
     C ret; 
     Execute(// calls the abstract function with a lambda function as parameter 
     [ret, executeFunction](void) -> C  // lambda declaraction 
     {          // 
      ret = executeFunction;    // lambda body 
     });          // 
     return ret; 
    } 
}; 

class ExampleExecutor : public TransparentFunctionWrapper 
{ 
public: 
    virtual void Execute(std::function<void()> executeFunction) 
    { 
     printf("executed before."); 
     executeFunction(); 
     printf("executed after."); 
    } 
}; 

void DoStuff() {} 
int ReturnStuff() { return -5; } 

int main() 
{ 
    ExampleExecutor executor; 

    executor.Execute(DoStuff); 
    int i = executor.Execute<int>(ReturnStuff);  // Why does this not work? ERROR: "type name is not allowed" 

    getchar(); 
    return 0; 
} 

Note: les marques Visual Studio

Execute<int>(ReturnStuff) // "int" is marked as Error: type name is not allowed 

La compilation met l'erreur

"type 'int' unexpected" 

Merci à tout le monde prêt à vous aider!

Answer 1

ExampleExecutor::Execute ne surcharge pas TransparentFunctionWrapper::Execute et il le masque dans l'appel executor.Execute<int>.

Vous devez explicitement appeler TransparentFunctionWrapper::Execute, car il est masqué par ExampleExecutor::Execute. Voici un moyen possible de le faire:

int i = executor.TransparentFunctionWrapper::Execute<int>(ReturnStuff); 

live example on coliru