Especialización en plantillas C ++ con < int & amp; > no recoger un int

Question

Tengo el siguiente código:

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

Y luego:

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

Quiero que funcione como cin > > sí, es decir, necesita escribir en abc el valor de retorno de la función lua. Por lo tanto, necesito su dirección ... pero está predeterminada en la plantilla predeterminada. ¿Qué estoy haciendo mal? Seguramente hay una manera de hacerlo, ya que cin hace exactamente eso.

¡Gracias!

---

Nota para quien cambió los% 's a > > ;: lo cambié de nuevo ya que es así: D El código llama a la prueba de función Lua (" test " ;, 5, nil, 2.333) y guarda su valor de retorno a abc. Los% son para los parámetros de las funciones, > > son para los valores de retorno.

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

Answer 1

Has escrito operador > > como operador unario, pero es un operador binario. LeftHandSide > > RightHandSide .

La forma std :: cout < " Hola " < < " world " ;; es (operator < < (operator < < (std :: cout, " Hello "), " world) ; - el primer < ; < devuelve std :: cout para usar como el lado izquierdo del segundo < < .

El verdadero problema es que en su código, la búsqueda ocurre de la siguiente manera:

1. Se determinan las funciones de Candiate (solo un candidato, la plantilla)
2. T se deduce.
3. Determine qué especialización (si existe) para instanciar.

En el paso 2, T == int. En el paso 3, no hay especializaciones para T == int , por lo que la plantilla base se elige e instancia. Es posible que desee utilizar una sobrecarga en lugar de una especialización. La sobrecarga sería una mejor coincidencia en el paso 1 para que ni siquiera llegue al punto de la deducción de argumento de plantilla

Answer 2

No puede usar valores constantes ( " test ", 5 o 2.333 ) donde se esperan referencias. Cambie la plantilla y el tipo de parámetro de su operador > > a ( int, float etc.) cuando desee este comportamiento.

Answer 3

Para uno, el operador > > es un operador binario . Eso significa que tiene que tomar dos argumentos. El primer argumento tiene que ser cualquiera que sea el tipo de

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

Dado que ese operador devuelve LuaCall & amp; , supongo que ese es el resultado de esa llamada (y, por lo tanto, argumento izquierdo).

De ese mResult supongo que intentas hacer ese operador como miembro de la clase. Pero no creo que pueda especializar plantillas de miembros.

Finalmente, no creo que deba especializarse para los tipos de referencia. Esto

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

debería hacer