Specializzazione template C ++ con < int & amp; > non raccogliendo un int

Question

Ho il seguente codice:

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

E poi:

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

Voglio che funzioni un po 'come cin > > lo fa, cioè deve scrivere per abc il valore di ritorno della funzione lua. Quindi ho bisogno del suo indirizzo .. ma per impostazione predefinita è il modello predefinito. Che cosa sto facendo di sbagliato? C'è sicuramente un modo per farlo poiché cin fa esattamente questo.

Grazie!

---

Nota a chiunque abbia cambiato% 's in > > ;: l'ho cambiato di nuovo poiché è così: D Il codice chiama il test di funzione Lua (" test " ;, 5, nil, 2.333) e salva il suo valore di ritorno in abc. % sono per i parametri delle funzioni, > > sono per i valori di ritorno.

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

Answer 1

Hai scritto l'operatore > > come operatore unario, ma è un operatore binario. LeftHandSide > > RightHandSide .

Il modulo std :: cout < " Hello " & Lt; < & Quot; world " ;; è quindi (operator < < (operator < < (std :: cout, " Hello "), " world) ; - il primo < ; < restituisce std :: cout da utilizzare come lato sinistro del secondo < < .

Il vero problema è che nel tuo codice la ricerca avviene come segue:

1. Le funzioni dei candidati sono determinate (solo un candidato, il modello)
2. T viene dedotto.
3. Determina la specializzazione (se presente) da istanziare.

Al passaggio 2, T == int. Nel passaggio 3 non ci sono specializzazioni per T == int , quindi il modello di base viene scelto e istanziato. Potresti voler usare un sovraccarico invece di una specializzazione. Il sovraccarico sarebbe una corrispondenza migliore nel passaggio 1, quindi non arriverai nemmeno al punto di deduzione dell'argomento modello

Answer 2

Non è possibile utilizzare valori costanti ( " test ", 5 o 2.333 ) dove sono previsti riferimenti. Cambia il modello e il tipo di parametro del tuo operatore > > in ( int, float ecc.) Quando vuoi questo comportamento.

Answer 3

Per uno, l'operatore > > è un operatore binario . Ciò significa che deve prendere due argomenti. Il primo argomento deve essere qualunque sia il tipo di

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

Dato che quell'operatore restituisce LuaCall & amp; , suppongo che sia questo il risultato di quella chiamata (e quindi argomento a sinistra).

Da quel mResult suppongo che tu tenti di fare quell'operatore come membro della classe. Ma non penso che tu possa specializzare i template dei membri.

Infine, non penso che dovresti specializzarti per i tipi di riferimento. Questo

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

dovrebbe fare