std :: function kullanırken bu <çözülmemiş aşırı yüklenmiş işlev türü> hatasını nasıl çözebilirim?

Question

Aşağıdaki örnekte kod örneği register_enum() işlevi bir numaralandırma üzerinde yineleme yapmak ve bir enum değerini c-stringine dönüştürmek için bir kullanıcı tarafından sağlanan geri aramayı çağırmak için kullanılır. Tüm numaralandırmalar bir sınıf içinde tanımlanır ve dizge çevirme için enum statik bir to_cstring (enum) işleviyle yapılır. Bir sınıf (aşağıdaki gölgelendirici sınıfı gibi) birden fazla numaralandırma ve buna karşılık gelen aşırı to_cstring (enum) işlevine sahipse, derleyici hangi to_cstring() işlevinin register_enum() öğesine geçeceğine karar veremez.) (

$ 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)>) 

nasıl register_enum doğru to_cstring işlevini geçmesi: Ben

#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; 
} 

Derleyici çıktı ... kod benden daha iyi açıklıyor düşünüyorsun? Bireysel to_cstring() işlevlerini yeniden adlandırabileceğimin farkındayım ama mümkünse bunu önlemek istiyorum. Belki tasarımım kokuşmuş ve daha iyi bir yaklaşım önerebilirsin.

Sorumu Calling overloaded function using templates (unresolved overloaded function type compiler error) ve How to get the address of an overloaded member function?'a benzer görünüyor ancak şu ana kadar bu bilgileri kendi sorunumda uygulayamıyorum.

Answer 1

Hata, kullanılabilecek iki olası aşırı yüklenme olduğunu ve derleyicinin sizin için karar veremediğini bildirir. Öte yandan, bir döküm kullanarak, kullanmak hangi birini belirleyebilirsiniz:

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

^* Not:

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

Veya (daha sert bir okuma için tek satırlık olarak) typedef olmadan

İşlev imzalarında, üst düzey const kaldırılıyor.

Bir sonraki soru, derleyicinin neden kendi başına uygun bir aşırı yük bulamadı? Sorun şu ki, register_enum aramasında enum'un türünü geçirirsiniz ve bu, std::function türünün std::function< const char* (shader::FUNC) > olması gerektiğini belirler, ancak std::function, bir şablon oluşturucuya sahiptir ve yapıcıya argüman türünü bulmaya çalışmadan önce , derleyici, kullanmak istediğiniz aşırı yükü bilmek zorundadır.

Answer 2

Bu durumda, eğer derleyici iki aşırı yüklenme arasında karar alamıyorsa, bunlardan birini yeniden adlandırmalısınız! Bu, işlevlerin daha da belirsiz kullanımını engeller.