Wie behebe ich diesen Fehler <nicht behobener überladener Funktionstyp>, wenn ich std :: function verwende?

Question

Im folgenden Codebeispiel (Arbeitscode) wird die templated register_enum() - Funktion verwendet, um eine Aufzählung zu durchlaufen und einen vom Benutzer bereitgestellten Callback aufzurufen, um einen Aufzählungswert in eine C-Zeichenfolge zu konvertieren. Alle Aufzählungen sind innerhalb einer Klasse definiert, und die Umwandlung von Enum in String erfolgt mit einer statischen to_cstring (enum) -Funktion. Wenn eine Klasse (wie die Shader-Klasse) mehr als eine Enumeration und die entsprechende überladene to_cstring (enum) -Funktion hat, kann der Compiler nicht entscheiden, welche der korrekten to_cstring() -Funktionen an register_enum() übergeben werden soll. Ich denke, der Code erklärt besser als ich ...

#include <functional> 
#include <iostream> 

// Actual code uses Lua, but for simplification 
// I'll hide it in this example. 
typedef void lua_State; 

class widget 
{ 
    public: 
     enum class TYPE 
     { 
      BEGIN = 0, 
      WINDOW = BEGIN, 
      BUTTON, 
      SCROLL, 
      PROGRESS, 
      END 
     }; 

     static const char *to_cstring(const TYPE value) 
     { 
      switch (value) 
      { 
       case TYPE::WINDOW: return "window"; 
       case TYPE::BUTTON: return "button"; 
       case TYPE::SCROLL: return "scroll"; 
       case TYPE::PROGRESS: return "progress"; 
       default: break; 
      } 
      return nullptr; 
     } 
}; 

class shader 
{ 
    public: 
     enum class FUNC 
     { 
      BEGIN = 0, 
      TRANSLATE = BEGIN, 
      ROTATE, 
      SCALE, 
      COLOR, 
      COORD, 
      END 
     }; 

     enum class WAVEFORM 
     { 
      BEGIN = 0, 
      SINE = BEGIN, 
      SQUARE, 
      TRIANGLE, 
      LINEAR, 
      NOISE, 
      END 
     }; 

     static const char *to_cstring(const FUNC value) 
     { 
      switch (value) 
      { 
       case FUNC::TRANSLATE: return "translate"; 
       case FUNC::ROTATE: return "rotate"; 
       case FUNC::SCALE: return "scale"; 
       case FUNC::COLOR: return "color"; 
       case FUNC::COORD: return "coord"; 
       default: break; 
      } 
      return nullptr; 
     } 

     static const char *to_cstring(const WAVEFORM value) 
     { 
      switch (value) 
      { 
       case WAVEFORM::SINE: return "sine"; 
       case WAVEFORM::SQUARE: return "square"; 
       case WAVEFORM::TRIANGLE: return "triangle"; 
       case WAVEFORM::LINEAR: return "linear"; 
       case WAVEFORM::NOISE: return "noise"; 
       default: break; 
      } 
      return nullptr; 
     } 
}; 

// Increment an enum value. 
// My compiler (g++ 4.6) doesn't support type_traits for enumerations, so 
// here I just static_cast the enum value to int... Something to be fixed 
// later... 
template < class E > 
E &enum_increment(E &value) 
{ 
    return value = (value == E::END) ? E::BEGIN : E(static_cast<int>(value) + 1); 
} 

widget::TYPE &operator++(widget::TYPE &e) 
{ 
    return enum_increment<widget::TYPE>(e); 
} 

shader::FUNC &operator++(shader::FUNC &e) 
{ 
    return enum_increment<shader::FUNC>(e); 
} 

shader::WAVEFORM &operator++(shader::WAVEFORM &e) 
{ 
    return enum_increment<shader::WAVEFORM>(e); 
} 


// Register the enumeration with Lua 
template< class E > 
void register_enum(lua_State *L, const char *table_name, std::function< const char*(E) > to_cstring) 
{ 
    (void)L; // Not used in this example. 
    // Actual code creates a table in Lua and sets table[ to_cstring(i) ] = i 
    for (auto i = E::BEGIN; i < E::END; ++i) 
    { 
     // For now, assume to_cstring can't return nullptr... 
     const char *key = to_cstring(i); 
     const int value = static_cast<int>(i); 
     std::cout << table_name << "." << key << " = " << value << std::endl; 
    } 
} 

int main(int argc, char **argv) 
{ 
    (void)argc; (void)argv; 

    lua_State *L = nullptr; 

    // Only one to_cstring function in widget class so this works... 
    register_enum<widget::TYPE>(L, "widgets", widget::to_cstring); 

    // ... but these don't know which to_cstring to use. 
    register_enum<shader::FUNC>(L, "functions", shader::to_cstring); 
    //register_enum<shader::WAVEFORM>(L, "waveforms", shader::to_cstring); 

    return 0; 
} 

Compiler Ausgabe:

$ g++ -std=c++0x -Wall -Wextra -pedantic test.cpp -o test && ./test 
test.cpp: In function ‘int main(int, char**)’: 
test.cpp:140:69: error: no matching function for call to ‘register_enum(lua_State*&, const char [10], <unresolved overloaded function type>)’ 
test.cpp:140:69: note: candidate is: 
test.cpp:117:7: note: template<class E> void register_enum(lua_State*, const char*, std::function<const char*(E)>) 

Wie gebe ich die richtige to_cstring Funktion register_enum()? Ich weiß, dass ich die einzelnen to_cstring() Funktionen umbenennen könnte, aber ich möchte das, wenn möglich, vermeiden. Vielleicht ist mein Design stinkig und Sie können einen besseren Ansatz empfehlen.

Meine Frage erscheint ähnlich wie Calling overloaded function using templates (unresolved overloaded function type compiler error) und How to get the address of an overloaded member function?, aber bis jetzt kann ich diese Informationen nicht auf mein spezifisches Problem anwenden.

Answer 1

Der Fehler besagt, dass zwei mögliche Überladungen verwendet werden können, und der Compiler kann nicht für Sie entscheiden.

typedef const char *(*func_ptr)(shader::FUNC); 
register_enum<shader::FUNC>(L, "functions", (func_ptr)shader::to_cstring); 

oder ohne typedef (in einem schwieriger zu lesen Einzeiler):

register_enum<shader::FUNC>(L, "functions", 
      (const char *(*)(shader::FUNC))shader::to_cstring); 

^* Hinweis Auf der anderen Seite können Sie die man verwenden, indem ein Guss bestimmen dass in den Funktionssignaturen die oberste Ebene const entfernt wird.

Die nächste Frage ist, warum hat der Compiler die entsprechende Überladung nicht selbst gefunden? Das Problem dort ist, dass in dem Aufruf an register_enum übergeben Sie den Typ der Enumeration, und das bestimmt den Typ der std::function zu std::function< const char* (shader::FUNC) >, aber std::function hat einen Konstruktor Vorlage, und bevor versucht, den Typ des Arguments für den Konstruktor abzuleiten Der Compiler muss wissen, welche Überladung Sie verwenden möchten.

Answer 2

Ich würde sagen, dass in diesem Fall, wenn der Compiler nicht zwischen den beiden Überladungen entscheiden kann, sollten Sie einen von ihnen umbenennen! Dies verhindert eine weitere mehrdeutige Verwendung der Funktionen.