Desafio C++

Função inline e sobrecarga com valores padrão

Enunciado

Crie uma função inline chamada multiplicar que aceita dois parâmetros int e retorna o produto. Crie também uma versão sobrecarregada que aceita três parâmetros int, sendo o terceiro com valor padrão 1. No main, chame multiplicar(3, 4), multiplicar(2, 5, 3) e multiplicar(7, 8). Imprima os resultados.

Requisitos

  • A função multiplicar deve ser marcada como inline.
  • Deve haver duas versões sobrecarregadas: uma com dois int, outra com três int (terceiro com valor padrão 1).
  • As funções retornam o produto dos argumentos.
  • O main chama as três formas e imprime os resultados.

Código inicial

#include <iostream>

// Defina as funções inline e sobrecarregadas

int main() {
    // Chame as funções e imprima
    return 0;
}

Saída esperada

multiplicar(3,4) = 12
multiplicar(2,5,3) = 30
multiplicar(7,8) = 56
Ver dica

Lembre-se de que inline é uma sugestão. Coloque a palavra-chave antes do tipo de retorno. Para o valor padrão, declare-o apenas na definição (ou na declaração, se houver).

Mostrar solução 
#include <iostream>

// Versão inline com dois parâmetros
inline int multiplicar(int a, int b) {
    return a * b;
}

// Versão inline sobrecarregada com três parâmetros, o terceiro com valor padrão 1
inline int multiplicar(int a, int b, int c = 1) {
    return a * b * c;
}

int main() {
    std::cout << "multiplicar(3,4) = " << multiplicar(3, 4) << '\n';
    std::cout << "multiplicar(2,5,3) = " << multiplicar(2, 5, 3) << '\n';
    std::cout << "multiplicar(7,8) = " << multiplicar(7, 8) << '\n';
    return 0;
}

Passo a passo

  1. Incluímos <iostream> para entrada/saída.
  2. Definimos inline int multiplicar(int a, int b) que retorna a * b.
  3. Definimos inline int multiplicar(int a, int b, int c = 1) que retorna a * b * c. O valor padrão 1 permite chamar com dois argumentos.
  4. No main, chamamos multiplicar(3, 4) — o compilador escolhe a versão de dois parâmetros.
  5. Chamamos multiplicar(2, 5, 3) — escolhe a versão de três parâmetros.
  6. Chamamos multiplicar(7, 8) — como há duas funções candidatas? A versão de três parâmetros pode ser chamada com dois argumentos devido ao valor padrão, mas a versão de dois parâmetros é mais específica. O compilador prefere a de dois parâmetros por ser uma correspondência exata. Portanto, não há ambiguidade.
  7. Imprimimos os resultados.

Por que funciona

A sobrecarga com valor padrão pode criar ambiguidade se não houver uma versão exata. Neste caso, a versão de dois parâmetros é preferida para chamadas com dois argumentos, pois não requer o uso do valor padrão. O inline sugere ao compilador expandir a função, mas não é obrigatório; é uma otimização.

Erros comuns

  • Declarar o valor padrão na definição e também em uma declaração anterior: erro de redefinição de valor padrão.
  • Esquecer inline em uma das versões: não é erro, mas não atende ao requisito.
  • Chamar multiplicar(3, 4, 1) e esperar a versão de dois parâmetros: o compilador escolhe a de três parâmetros, pois corresponde exatamente.
  • Não incluir <iostream>: erro de compilação.

Outra forma de resolver

Usar uma única função com três parâmetros e valor padrão para o terceiro, e chamar sempre com três argumentos. Mas isso não demonstra sobrecarga. A sobrecarga é útil quando a versão com menos parâmetros tem uma implementação diferente ou mais eficiente.

Saída esperada

multiplicar(3,4) = 12
multiplicar(2,5,3) = 30
multiplicar(7,8) = 56