Como retornar o tipo correto de dados nos modelos?

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

Aqui estou usando modelos no CPP; portanto, quando chamo a função bigignorando argumentos de doublee intdigite, quero a resposta de retorno que é double. O tipo aqui, ele retorna em 32vez de 32.8.

Como obtenho a saída desejada? Como escrever um tipo de retorno de bigfunção adequado ?

Uma função pode ter apenas um tipo de retorno que precisa ser conhecido no momento da compilação. No entanto, você pode usar std::common_type, para retornar um tipo no qual os dois parâmetros possam ser implicitamente convertidos.

Isso seria

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

E para verificar se, na verdade, retorna a doublequando passou a inte a double, podemos fazer:

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

Que imprime

1

PS: std::common_typepode usar o operador ternário por trás das notas e, como tal, esta solução não é muito diferente das outras respostas ( auto+ ternário). O poder real std::common_typeé que ele aceita qualquer número de parâmetros.

O tipo de retorno deve ser determinado em tempo de compilação. Você pode usar o retorno à direita com um operador condicional , se estiver 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 ao vivo

No entanto, se você tiver acesso ao c ++ 14 ou superior, o autoretorno é suficiente, pois o compilador deduzirá o tipo certo se você o usar junto com o operador condicional da seguinte maneira:

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

Ver ao vivo

Ao marcar seu tipo de retorno como Ye passar um intcomo seu segundo parâmetro, você indicou claramente que Yé um int. Não há surpresas acontecendo aqui.

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

Isso imprime todos os quatro valores corretos na tela.

https://godbolt.org/z/fyGsmo

Uma coisa que é importante observar é que isso funcionará apenas para tipos que podem ser comparados entre si, ou seja, o compilador converterá implicitamente um tipo em outro para a comparação.

IMPORTANTE : Os parâmetros precisam ser tomados por referência para evitar comportamento indefinido. Isso tem a ver com o tipo de retorno pelo qual estou teimosamente. decltype(auto)pode retornar referências a tipos. Se você retornar algo local para a função (contagem de argumentos), obterá um comportamento indefinido.

Esta não é a solução correta para sua situação precisa, com toda a probabilidade - as outras respostas provavelmente estarão muito mais próximas do que você deseja.

No entanto, se você realmente precisar retornar tipos totalmente diferentes em tempo de execução por algum motivo, a solução correta (desde o c ++ 17 ) é usar a std::variant, que é uma espécie de união com segurança de tipo.

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

Observe que o ônus está no chamador para lidar com o valor retornado, provavelmente usando std::visitou algo parecido.

Ele retorna int porque Y é um int e lança 32,8 para ele. Quando você chamou big 32,82, é float, mas 8 é int e o tipo de retorno da função é Y, que também é int.

Você não pode realmente consertar isso, pois precisa saber em tempo de execução que tipo retornos grandes, portanto, faça aeb do mesmo 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);
    }