Comment puis-je résoudre ce <non résolus fonction surchargée type> erreur lors de l'utilisation de std::function?
Dans la suite (de travail) exemple de code, basé sur un modèle register_enum() la fonction est utilisée pour effectuer une itération sur une énumération et l'appel d'un utilisateur, dans la mesure de rappel à la conversion d'une valeur d'énumération à un c-string. Tous les énumérations sont définies dans une classe, et l'énumération de la chaîne de conversion est accompli avec un statique to_cstring( enum ) de la fonction. Lorsqu'une classe (comme le shader de classe ci-dessous) a plus d'une énumération et correspondant surchargé to_cstring( enum ) de la fonction, le compilateur ne peut pas décider lequel est le bon to_cstring() pour passer à register_enum(). Je pense que le code explique mieux que je peux...
#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;
}
Sortie du compilateur:
$ 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)>)
Comment puis-je passer le bon to_cstring fonction de register_enum()? Je me rends compte que je pouvais renommer l'individu to_cstring() fonctionne, mais je voudrais éviter si possible. Peut-être que ma conception est de l'odeur et vous pouvez recommander une meilleure approche.
Ma question semble similaire à L'appel de fonction surchargée à l'aide de modèles (en suspens fonction surchargée type d'erreur du compilateur) et Comment faire pour obtenir l'adresse d'une fonction membre surchargée? mais jusqu'à présent, je suis incapable de mettre cette information à mon problème spécifique.
OriginalL'auteur x-x | 2012-04-06
Vous devez vous connecter pour publier un commentaire.
L'erreur vous indique qu'il y a deux potentiels des surcharges qui pourraient être utilisés, et le compilateur ne peut pas décider pour vous. D'autre part, vous pouvez déterminer à utiliser à l'aide d'un cast:
Ou sans le typedef (en plus difficile de lire le one-liner):
*Notez que dans les signatures de la fonction, le niveau supérieur de la
const
est supprimé.La prochaine question est de savoir pourquoi le compilateur ne pas trouver la surcharge de travail en lui-même? Le problème, c'est que dans l'appel à
register_enum
vous passez le type de l'enum, et qui détermine le type de lastd::function
êtrestd::function< const char* ( shader::FUNC ) >
, maisstd::function
est basé sur un modèle du constructeur, et avant d'essayer d'en déduire le type de l'argument du constructeur, le compilateur doit connaître la surcharge que vous souhaitez utiliser.OriginalL'auteur David Rodríguez - dribeas
Je dirais que dans ce cas, si le compilateur ne peut pas décider entre les deux surcharges, vous devez renommer l'un d'entre eux! Cela empêchera plus ambiguë de l'utilisation des fonctions.
OriginalL'auteur xcski