Fácil C++

Maior de dois valores

Enunciado

Crie um template de função maior que recebe dois valores de qualquer tipo e retorna o maior deles. Use template<typename T>. No main, chame a função com int, double e std::string e imprima os resultados.

Requisitos

  • A função deve ser um template com template<typename T>.
  • Deve comparar os dois argumentos com > e retornar o maior.
  • O main deve chamar a função com pelo menos três tipos diferentes.
  • A saída deve mostrar os três resultados.

Código inicial

#include <iostream>
#include <string>

// TODO: implemente o template maior

int main() {
    // TODO: chame maior com int, double e string
    return 0;
}

Saída esperada

7
3.14
banana
Ver dica

O corpo da função é simplesmente return (a > b) ? a : b;. O compilador deduz T a partir dos argumentos.

Mostrar solução 
#include <iostream>
#include <string>

// Template genérico: retorna o maior entre dois valores
template<typename T>
T maior(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    // Dedução: T = int
    std::cout << maior(3, 7) << '\n';
    // Dedução: T = double
    std::cout << maior(2.71, 3.14) << '\n';
    // Dedução: T = std::string (comparação lexicográfica)
    std::cout << maior(std::string("banana"), std::string("abacaxi")) << '\n';
    return 0;
}

Passo a passo

  1. Incluímos <iostream> e <string> para entrada/saída e para o tipo std::string.
  2. Declaramos template<typename T> antes da função, indicando que T é um parâmetro de tipo genérico.
  3. A função maior recebe dois parâmetros do tipo T e retorna T. O corpo usa o operador ternário para escolher o maior.
  4. No main, a primeira chamada maior(3, 7) faz o compilador deduzir T = int e instanciar a função para int.
  5. A segunda chamada maior(2.71, 3.14) deduz T = double e instancia outra versão.
  6. A terceira chamada usa std::string; o compilador deduz T = std::string e instancia a versão que compara strings lexicograficamente.
  7. Cada instanciação é uma função independente gerada em tempo de compilação.

Por que funciona

Templates de função permitem que o mesmo código seja reutilizado para vários tipos. O compilador analisa os tipos dos argumentos e gera automaticamente a versão correta da função — isso é a dedução de tipos seguida de instanciação. Como a comparação > está definida para int, double e std::string, o template compila para todos eles.

Erros comuns

  • Esquecer template<typename T> antes da função: o compilador não reconhece T e gera erro.
  • Passar tipos diferentes, como maior(3, 4.5): a dedução falha porque T não pode ser int e double ao mesmo tempo. Nesse caso, use maior<double>(3, 4.5) para forçar a instanciação.
  • Usar tipos que não suportam > (ex.: uma struct sem operator>): o erro só aparece na instanciação, com mensagem de compilação detalhada.

Outra forma de resolver

Se quiser aceitar tipos diferentes, pode usar dois parâmetros de tipo:

template<typename T, typename U>
auto maior(T a, U b) -> decltype(a > b ? a : b) {
    return (a > b) ? a : b;
}

Isso é útil quando os argumentos têm tipos distintos, mas exige cuidado com o tipo de retorno.

Saída esperada

7
3.14
banana