Jak zwrócić poprawny typ danych w szablonach?

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

Tutaj używam szablonów w CPP, więc kiedy bigwywołuję funkcję z pominięciem argumentów doublei inttypu, chcę uzyskać odpowiedź zwrotną, która jest double. Wpisz tutaj, zwraca 32zamiast 32.8.

Jak uzyskać pożądaną wydajność? Jak napisać odpowiedni typ zwracanej bigfunkcji?

Funkcja może mieć tylko jeden typ zwracany, który musi być znany w czasie kompilacji. Można jednak użyć std::common_type, aby zwrócić typ, dla którego oba parametry mogą być konwertowane implicite.

To by było

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

I aby sprawdzić, czy faktycznie zwraca a doublepo przejściu inti a doublemożemy zrobić:

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

Które wydruki

1

PS: std::common_typemoże korzystać z trójskładnikowego operatora za sceną i jako takie rozwiązanie nie różni się niczym od innych odpowiedzi ( auto+ trójskładnikowe). Prawdziwą siłą std::common_typejest to, że akceptuje dowolną liczbę parametrów.

Typ zwracany musi zostać określony w czasie kompilacji. Możesz użyć końcowego powrotu z operatorem warunkowym , jeśli jesteś ograniczony do 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;
}

Zobacz na żywo

Jeśli jednak masz dostęp do c ++ 14 lub wyższej, autowystarczy, że kompilator wydedukuje odpowiedni typ, jeśli użyjesz go razem z operatorem warunkowym w następujący sposób:

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

Zobacz na żywo

Oznaczając typ zwrotu jako Yi przekazując intjako drugi parametr, wyraźnie wskazałeś, że Yjest to int. Nie ma tu niespodzianek.

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

Spowoduje to wydrukowanie wszystkich czterech poprawnych wartości na ekranie.

https://godbolt.org/z/fyGsmo

Jedną rzeczą, na którą należy zwrócić uwagę, jest to, że będzie to działać tylko dla typów, które można porównywać ze sobą, tj. Kompilator niejawnie przekonwertuje jeden typ na drugi dla porównania.

WAŻNE : parametry należy traktować jako odniesienie, aby uniknąć nieokreślonego zachowania. Ma to związek z typem zwrotu, którego uparcie się trzymam. decltype(auto)może zwracać odniesienia do typów. Jeśli zwrócisz coś lokalnego do funkcji (liczą się argumenty), otrzymasz niezdefiniowane zachowanie.

Prawdopodobnie nie jest to właściwe rozwiązanie dla Twojej precyzyjnej sytuacji - inne odpowiedzi prawdopodobnie będą znacznie bliżej tego, czego chcesz.

Jeśli jednak z jakiegoś powodu naprawdę musisz zwracać całkowicie różne typy w środowisku wykonawczym, poprawnym rozwiązaniem (od wersji c ++ 17 ) jest użycie std::variantunii, która jest rodzajem unii bezpiecznej dla typu.

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

Zauważ, że wtedy na dzwoniącym spoczywa ciężar radzenia sobie ze zwróconą wartością, najprawdopodobniej za pomocą std::visititp.

Zwraca int, ponieważ Y jest int i rzuca na niego 32.8. Gdy nazwiesz dużą, 32,82 jest liczbą zmiennoprzecinkową, ale 8 jest liczbą całkowitą, a typem funkcji jest Y, która również jest liczbą całkowitą.

Naprawdę nie możesz tego naprawić, ponieważ musisz wiedzieć w czasie wykonywania, które typy dużych zwrotów, więc ułóż aib typu tego samego typu:

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