¿Cómo devolver el tipo correcto de datos en las plantillas?

#include <iostream>
using namespace std;

template <class X, class Y>
Y big(X a, Y b)
{
   if (a > b)
      return (a);
   else return (b);
}

int main()
{
   cout << big(32.8, 9);
}

Aquí estoy usando plantillas en CPP, así que cuando llamo a la función sin bigpasar por argumentos doubley inttipo, quiero la respuesta de retorno que es double. El tipo aquí, devuelve en 32lugar de 32.8.

¿Cómo obtengo el resultado deseado? ¿Cómo escribir un tipo de bigfunción de retorno adecuado ?

Una función solo puede tener un tipo de retorno que debe conocerse en tiempo de compilación. Sin embargo, puede usar std::common_type, para devolver un tipo al que ambos parámetros se pueden convertir implícitamente.

Eso sería

#include <type_traits>
template <class X, class Y>
typename std::common_type<X,Y>::type big(X a, Y b)
{
   if (a > b)
      return a;
   else return b;
}

Y para comprobar que en realidad devuelve un doublecuando se pasa un inty un doublepodemos hacer:

int main() {
    auto x = big(4.2,42);
    std::cout << std::is_same<decltype(x),double>::value;
}

Que imprime

1

PD: std::common_typepuede usar el operador ternario detrás de los escenarios y, como tal, esta solución no es muy diferente de las otras respuestas ( auto+ ternary). El verdadero poder de std::common_typees que acepta cualquier número de parámetros.

El tipo de retorno debe determinarse en tiempo de compilación. Puede usar el retorno final con un operador condicional , si está limitado a c ++ 11 .

template <typename X, typename Y>
auto big(X&& a, Y&& b) -> decltype(a > b ? a : b) // ---> like this
{
   return  a > b ? a : b;
}

Ver en vivo

Sin embargo, si tiene acceso a c ++ 14 o superior, el autoretorno es suficiente, ya que el compilador deducirá el tipo correcto si lo usa junto con el operador condicional de la siguiente manera:

template <typename X, typename Y>
auto big(X a, Y b)
{
   return  a > b ? a : b;
}

Ver en vivo

Al marcar su tipo de retorno como Yy pasar un intcomo su segundo parámetro, ha indicado claramente que Yes un int. No hay sorpresas pasando aquí.

#include <iostream>

template <typename X, typename Y>
decltype(auto) big(const X& a, const Y& b)  // return type can just be auto as well 
{
    return a > b ? a : b;
}

int main()
{
    std::cout << big(32.8, 9) << '\n';
    std::cout << big(9, 32.8) << '\n';
    std::cout << big(32.8, 90) << '\n';
    std::cout << big(90, 32.8) << '\n';
}

Esto imprime los cuatro valores correctos en la pantalla.

https://godbolt.org/z/fyGsmo

Una cosa que es importante tener en cuenta es que esto solo funcionará para los tipos que se pueden comparar entre sí, es decir, el compilador convertirá implícitamente un tipo al otro para la comparación.

IMPORTANTE : los parámetros deben tomarse por referencia para evitar un comportamiento indefinido. Esto tiene que ver con el tipo de retorno al que terco tercamente. decltype(auto)puede devolver referencias a tipos. Si devuelve algo local a la función (recuento de argumentos), obtendrá un comportamiento indefinido.

Esta no es la solución correcta para su situación precisa, con toda probabilidad: es probable que las otras respuestas estén mucho más cerca de lo que desea.

Sin embargo, si realmente necesita devolver tipos completamente diferentes en tiempo de ejecución por alguna razón, la solución correcta (desde c ++ 17 ) es usar a std::variant, que es una especie de unión de tipo seguro.

#include <variant>

template <typename X, typename Y>
std::variant<X, Y> max(X a, Y b) {
  if (a > b)
    return std::variant<X, Y>(std::in_place_index_t<0>, a);
  else
    return std::variant<X, Y>(std::in_place_index_t<1>, b);
}

Tenga en cuenta que entonces la responsabilidad recae en la persona que llama para tratar con el valor devuelto, lo más probable es que use std::visito similar.

Devuelve int porque Y es un int y le envía el 32.8. Cuando llamaste a big 32,82 es flotante, pero 8 es int y el tipo de retorno de función es Y, que también es int.

Realmente no puede solucionar esto, ya que necesita saber en tiempo de ejecución qué tipo de grandes retornos, por lo tanto, haga que ayb sean del mismo tipo:

    #include <iostream>
    using namespace std;

    template <typename X>

    X big (X a, X b)
    {
    if (a>b)
    return a;

    else return b;
    }

    int main()
    {
    cout<< big (32.8, 9.0);
    }