Spécialisation de modèles C ++ avec < int & amp; > ne pas ramasser un int

Question

J'ai le code suivant:

template <typename T> LuaCall& operator>>(T) { BOOST_STATIC_ASSERT(sizeof(T) == 0); }
template <> LuaCall& operator>><int&>(int& val) { mResults.push_back(std::make_pair(LUA_RESULT_INTEGER, (void *)&val)); return *this; }
template <> LuaCall& operator>><float&>(float& val) { mResults.push_back(std::make_pair(LUA_RESULT_FLOAT, (void *)&val)); return *this; }
template <> LuaCall& operator>><double&>(double& val) { mResults.push_back(std::make_pair(LUA_RESULT_DOUBLE, (void *)&val)); return *this; }
template <> LuaCall& operator>><bool&>(bool& val) { mResults.push_back(std::make_pair(LUA_RESULT_BOOLEAN, (void *)&val)); return *this; }
template <> LuaCall& operator>><std::string&>(std::string& val) { mResults.push_back(std::make_pair(LUA_RESULT_STRING, (void *)&val)); return *this; }
template <> LuaCall& operator>><LuaNilStruct>(LuaNilStruct) { mResults.push_back(std::make_pair(LUA_RESULT_NIL, (void *)NULL)); return *this; }

Et ensuite:

int abc;
LuaCall(l, "test") % "test" % 5 % LuaNil % 2.333 >> abc;

Je veux que cela fonctionne un peu comme cin > > fait, c’est-à-dire qu’il doit écrire dans abc la valeur de retour de la fonction lua. J'ai donc besoin de son adresse .. mais il utilise par défaut le modèle par défaut. Qu'est-ce que je fais mal? Il y a sûrement un moyen de faire cela puisque cin fait exactement cela.

Merci!

Note à celui qui a changé les% en: > >: je les ai modifiés car c'est ainsi: D Le code appelle la fonction test de Lua ("test", 5, nil, 2.333) et enregistre sa valeur de retour à abc. Les% sont pour les paramètres des fonctions, > > sont pour les valeurs de retour.

template <typename T>
LuaCall& operator%(T val) {
    mLua->Push(val);
    ++mArguments;
    return *this;
}

Answer 1

Vous avez écrit l'opérateur > > en tant qu'opérateur unaire, mais c'est un opérateur binaire. LeftHandSide > > RightHandSide .

Le formulaire std :: cout < " Bonjour " < < " world " ;; est donc (opérateur < < (opérateur < < & std :: cout, "Hello"), " world) ; - le premier < ; < renvoie std :: cout à utiliser comme partie gauche du second < < .

Le vrai problème est que dans votre code, la recherche se déroule comme suit:

1. Les fonctions candiate sont déterminées (un seul candidat, le modèle)
2. T est déduit.
3. Déterminez la spécialisation (le cas échéant) à instancier.

À l'étape 2, T == int. À l'étape 3, il n'y a pas de spécialisations pour T == int . Le modèle de base est donc choisi et instancié. Vous voudrez peut-être utiliser une surcharge au lieu d'une spécialisation. La surcharge correspondrait mieux à l’étape 1 afin que vous n’en arriviez même pas au point de déduction des arguments de modèle

Answer 2

Vous ne pouvez pas utiliser de valeurs constantes ( "test", 5 ou 2.333 ) lorsque des références sont attendues. Modifiez le type et le type de paramètre de votre opérateur > > en ( int, float , etc.) lorsque vous souhaitez ce comportement.

Answer 3

D'une part, l'opérateur > > est un opérateur binaire . Cela signifie qu'il faut prendre deux arguments. Le premier argument doit être quel que soit le type de

LuaCall(l, "test") % "test" % 5 % LuaNil % 2.333

Puisque cet opérateur retourne LuaCall & , je suppose que c'est le résultat de cet appel (et donc de l'argument de gauche).

À partir de ce mResult , je suppose que vous essayez de faire cet opérateur en tant que membre de la classe. Mais je ne pense pas que vous puissiez spécialiser les modèles de membre.

Enfin, je ne pense pas que vous deviez vous spécialiser pour les types de référence. Cette

template <> LuaCall& operator>><int>(int val);

devrait faire