Objetivos de Aprendizagem

Ao finalizar esta aula, você terá aprendido a:

• Entender o propósito das funções e por que elas são essenciais em C++.
• Criar funções corretamente, garantindo um código estruturado.
• Invocar funções dentro de um programa e compreender como elas são executadas.
• Distinguir entre funções que retornam valores e aquelas que simplesmente executam instruções.
• Comparar diferentes formas de definir funções e escolher a melhor conforme a situação.

Declaração, Invocação e Definição de Funções

Em C++, as funções são blocos de código reutilizáveis que permitem estruturar um programa de maneira modular e organizada. Cada função encapsula uma tarefa específica, o que ajuda a melhorar a clareza e a manutenção do código. Para utilizar uma função em um programa, devemos seguir três etapas fundamentais: declaração, invocação e definição.

Esses três conceitos são essenciais, e cada um desempenha um papel específico na estrutura do código. Vamos analisá-los em detalhes.

1. Declaração de uma função

   Antes que uma função possa ser usada no código, o compilador deve ser informado da sua existência. Isso é feito por meio de uma declaração de função ou protótipo.

   A declaração de uma função informa ao compilador três aspectos fundamentais:

   • O tipo de dado que a função retornará (ou void se não retornar nada).
   • O nome da função.
   • Os parâmetros que ela aceita (se houver), junto com seus tipos.

   A sintaxe geral de uma declaração de função é:

   tipo_de_retorno nome_da_funcao (lista_de_parametros);
   

   A declaração da função geralmente é colocada antes de main() ou em um arquivo de cabeçalho .h quando trabalhamos com múltiplos arquivos.

2. Invocação de uma função

   Após declarar uma função, podemos invocá-la, ou seja, chamá-la dentro do código para que seja executada.

   Quando uma função é invocada:

   • O código contido na sua definição é executado.
   • Se a função retorna um valor, ele pode ser armazenado em uma variável ou usado diretamente em uma expressão.
   • Se a função for do tipo void, ela apenas executa suas instruções sem retornar nada.

   A sintaxe para a invocação de uma função é simplesmente escrever seu nome seguido de parênteses com os argumentos (se necessário):

   nome_da_funcao(argumentos);
   

3. Definição da função:

   Finalmente, a definição da função é a parte onde seu comportamento é implementado. Aqui são especificadas as instruções que serão executadas quando a função for chamada.

   A sintaxe geral de uma definição de função é:

   tipo_de_retorno nome_da_funcao (lista_de_parametros) {
       // Corpo da função: instruções a serem executadas
       return valor; // (se a função retornar um valor)
   }
   

   Cada definição de função deve seguir as seguintes regras:

   • Deve ser compatível com a declaração (se foi previamente declarada).
   • Se a função retorna um valor (por exemplo, int), deve conter uma instrução return com o valor a ser retornado.
   • Se a função não retorna nada (void), apenas executa suas instruções e não precisa de return.

Fluxo de execução

Quando o programa é executado, as funções são chamadas na ordem em que aparecem dentro de main(). O fluxo de execução ocorre da seguinte forma:

1. O compilador reconhece a declaração da função.
2. Dentro de main(), quando uma chamada para a função é encontrada, o controle do programa é transferido para a definição da função.
3. A função executa suas instruções.
4. Se a função tem um valor de retorno, ele é devolvido para a linha onde foi invocada.
5. O fluxo do programa retorna para main() ou para a função que realizou a chamada.

Importância da declaração prévia

A declaração de funções antes do seu uso é crucial porque o compilador de C++ processa o código de cima para baixo. Se tentarmos chamar uma função antes que tenha sido definida ou declarada, ocorrerá um erro.

Existem duas formas principais de lidar com isso:

1. Declarar a função antes de main() e defini-la depois (como visto até agora).
2. Definir a função antes de main(), evitando assim a necessidade de uma declaração prévia.

Ambas as abordagens são válidas, mas a primeira é mais útil em programas grandes onde as funções estão em arquivos distintos.

Abordagem: Declarar – Invocar – Definir

Uma das abordagens mais utilizadas para estruturar funções em C++ é a de declarar – invocar – definir. Seguindo essa lógica, organizamos nosso código em três etapas fundamentais:

1. Declaração: Informa ao compilador sobre a existência da função antes de seu uso, especificando seu nome, tipo de retorno e parâmetros (se houver).
2. Invocação: A função é chamada dentro do código principal (main() na maioria dos casos), executando seu conteúdo.
3. Definição: Especifica a implementação da função, detalhando quais instruções serão executadas quando for invocada.

Essa estrutura melhora a organização do código, facilitando sua manutenção e escalabilidade. Vamos analisar um exemplo aplicando essa abordagem:

Exemplo: Função consoladiz()

No código a seguir, seguimos a sequência declarar – invocar – definir:

#include <iostream>
using namespace std;
// Primeiro declaramos a função
void consoladiz();
int main() {
    // Invocamos a função
    consoladiz();
    return 0;
}
// Definimos a função previamente declarada, detalhando seu funcionamento interno
void consoladiz() {
    cout << "Isto é uma simples cadeia de caracteres ou literais." << endl;
    cout << "Agora vou mostrar o número cinco. Aqui está: " << 5 << endl;
    cout << "Vamos ver o resultado de 10/5. O resultado é: " << 10/5 << endl;
    cout << "Uma forma típica de aproximar o número Pi é fazendo 22/7. O resultado é: " << 22/7 << endl;
    cout << "Em C++ não é a mesma coisa escrever 22/7 e 22.0/7, o tratamento é diferente." << endl;
    cout << "Com essa simples mudança podemos ver que 22.0/7 é igual a " << 22.0/7 << endl;
    cout << "Você não acha essa uma melhor aproximação?" << endl;
}

O resultado esperado deste código é:

Isto é uma simples cadeia de caracteres ou literais.
Agora vou mostrar o número cinco. Aqui está: 5
Vamos ver o resultado de 10/5. O resultado é: 2
Uma forma típica de aproximar o número Pi é fazendo 22/7. O resultado é: 3
Em C++ não é a mesma coisa escrever 22/7 e 22.0/7, o tratamento é diferente.
Com essa simples mudança podemos ver que 22.0/7 é igual a 3.14286
Você não acha essa uma melhor aproximação?

Para entender melhor a abordagem declarar – invocar – definir, vamos nos concentrar em três partes-chave do código:

1. Linha 5: Declaração da função
   • void consoladiz(); informa ao compilador que em algum ponto do código existirá uma função chamada consoladiz().
   • Especifica que seu tipo de retorno é void, o que significa que não retornará nenhum valor.
   • Ainda que a implementação de consoladiz() não seja conhecida neste momento, essa declaração permite que o compilador a reconheça quando for usada mais adiante.
2. Linha 9: Invocação da função
   • Dentro da função main(), a linha consoladiz(); executa a função.
   • Nesse momento, o compilador já reconhece a existência de consoladiz() graças à sua declaração prévia.
   • Quando a função é chamada, o controle do programa é transferido para sua definição, onde seu conteúdo é executado.
3. Linhas 14 a 22: Definição da função
   • Aqui está a implementação detalhada de consoladiz(), especificando suas instruções.
   • Nesse caso, a função imprime várias mensagens no console, incluindo números e operações matemáticas.
   • Um ponto importante é a diferença entre 22/7 e 22.0/7. Quando usamos 22/7, ambos os números são inteiros, resultando em 3 devido à divisão inteira. No entanto, ao escrever 22.0/7, forçamos a operação a ser realizada em ponto flutuante, obtendo 3.14286.

Abordagem: Declarar e Implementar antes de Invocar

Em C++, além da abordagem declarar – invocar – definir, existe outra maneira válida de estruturar nossas funções: declarar e implementar antes de invocar. Esse método combina a declaração e a definição em um único passo, antes que a função seja usada em main().

Nessa abordagem, em vez de fazer uma declaração prévia da função e defini-la depois de main(), nós a declaramos e definimos diretamente no mesmo local antes de invocá-la. Isso tem a vantagem de evitar uma declaração separada e tornar o código mais compacto e fácil de ler em programas pequenos.

A estrutura geral dessa abordagem é a seguinte:

// Definimos a função antes de main()
tipo_de_retorno nome_da_funcao(lista_de_parametros) {
    // Corpo da função
    return valor; // se necessário
}
int main() {
    // Invocação da função
    nome_da_funcao(argumentos);
}

Ao estar definida antes de main(), o compilador já a conhece quando ela é invocada, eliminando a necessidade de uma declaração prévia.

Exemplo: Função consoladiz() sem declaração prévia

Agora vejamos um exemplo prático onde aplicamos essa abordagem:

#include <iostream>
using namespace std;
// Definimos a função antes de invocá-la
void consoladiz() {
    cout << "Isto é uma simples cadeia de caracteres ou literais." << endl;
    cout << "Agora vou mostrar o número cinco. Aqui está: " << 5 << endl;
    cout << "Vamos ver o resultado de 10/5. O resultado é: " << 10/5 << endl;
    cout << "Uma forma típica de aproximar o número Pi é fazendo 22/7. O resultado é: " << 22/7 << endl;
    cout << "Em C++ não é a mesma coisa escrever 22/7 e 22.0/7, o tratamento é diferente." << endl;
    cout << "Com essa simples mudança podemos ver que 22.0/7 é igual a " << 22.0/7 << endl;
    cout << "Você não acha essa uma melhor aproximação?" << endl;
}
int main() {
    // Invocamos a função
    consoladiz();
    return 0;
}

Neste código podemos observar que:

1. Entre as linhas 5 e 13, a declaração e a definição são combinadas

   A função consoladiz() é definida diretamente antes de main(), sem a necessidade de uma declaração separada.

2. Na linha 17, a função é invocada dentro do main()

   Como a função já foi definida antes, o compilador a reconhece e permite sua execução sem problemas.

3. O resultado é exatamente o mesmo

   Funcionalmente, essa abordagem gera o mesmo comportamento que a abordagem declarar – invocar – definir, mas com uma estrutura mais compacta.

✅ Vantagens:

• Código mais direto e compacto em programas pequenos.
• Não requer uma declaração prévia, o que reduz a quantidade de linhas de código.
• Facilita a leitura em scripts curtos onde todas as funções estão em um único arquivo.

❌ Desvantagens:

• Em programas grandes, pode dificultar a organização se houver muitas funções definidas antes de main().
• Menos útil quando se trabalha com múltiplos arquivos (.h e .cpp), pois é preferível manter a declaração em um arquivo separado.

Propagação do Valor de Retorno

Até agora, trabalhamos com funções que simplesmente executam instruções sem retornar nenhum resultado. No entanto, em muitos casos, é necessário que uma função retorne um valor para que possa ser utilizado em outros cálculos ou armazenado em variáveis. Esse processo é conhecido como propagação do valor de retorno.

Nesta seção, aprenderemos como funcionam as funções que retornam valores, em que elas se diferenciam das funções do tipo void e como podemos aproveitar esse mecanismo em C++.

Exemplo Prático: Função que calcula a área de um retângulo

Para ilustrar a propagação do valor de retorno, implementaremos uma função que recebe a base e a altura de um retângulo e calcula sua área.

#include <iostream>
using namespace std;
// Função que calcula a área de um retângulo e retorna o resultado
double calcularArea(double base, double altura) {
    return base * altura;
}
int main() {
    double base, altura;
    
    // Solicitamos ao usuário que insira os valores
    cout << "Digite a base do retângulo: ";
    cin >> base;
    cout << "Digite a altura do retângulo: ";
    cin >> altura;
    // Chamamos a função e armazenamos seu resultado
    double area = calcularArea(base, altura);
    // Exibimos o resultado
    cout << "A área do retângulo é: " << area << endl;
    
    return 0;
}

1. A função calcularArea() retorna um valor
   • Recebe dois valores (base e altura) como parâmetros.
   • Calcula a área por meio da multiplicação base * altura.
   • Utiliza return para enviar o resultado da operação para a parte do programa que a invocou.
2. Uso do valor de retorno em main()
   • Os valores de base e altura são inseridos pelo usuário.
   • A função calcularArea() é chamada, e seu resultado é armazenado na variável area.
   • Finalmente, o resultado é exibido no console.
3. Diferença chave com uma função void

   Se calcularArea() fosse do tipo void, teríamos que exibir o resultado diretamente dentro da função, em vez de retorná-lo para main() para uso posterior.

Exemplo: Função que determina se um número é par ou ímpar

#include <iostream>
using namespace std;
bool ehPar(int numero) {
    return numero % 2 == 0;
}
int main() {
    int numero;
    cout << "Digite um número: "; cin >> numero;
    if (ehPar(numero)) {
        cout << "O número é par." << endl;
    } else {
        cout << "O número é ímpar." << endl;
    }
    return 0;
}

Aqui, a função ehPar() retorna true se o número for par e false se for ímpar, permitindo que main() utilize o resultado para decidir qual mensagem exibir.

Recursividade: Funções que chamam a si mesmas

A recursividade é uma técnica em que uma função se chama a si mesma para resolver problemas dividindo-os em versões menores de si mesma. Ela é especialmente útil em algoritmos como o cálculo do fatorial, a sequência de Fibonacci e percursos em estruturas de dados como árvores.

Exemplo: Fatorial de um Número

O fatorial de um número n é n!=n\cdot(n-1)\cdot(n-2) \cdots 3 \cdot2 \cdot 1. Essa formulação possui uma estrutura recursiva que pode ser representada matematicamente da seguinte forma:

\begin{array}{rl} 0! &=1\\ n! &= n\cdot(n-1)!\\ \end{array}

Com isso em mente, podemos programar essa função em C++ da seguinte maneira:

#include <iostream>
using namespace std;
 
int fatorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return n * fatorial(n - 1);
}
 
int main() {
    int numero;
    cout << "Digite um número: "; cin >> numero;
    cout << "O fatorial de " << numero << " é " << fatorial(numero) << endl;
    return 0;
}

Neste código:

• A função fatorial(n) chama a si mesma com n-1 até atingir o caso base (n == 0 ou n == 1).
• A função é resolvida de forma recursiva, multiplicando os valores até encontrar o resultado.

Exemplo: Números de Fibonacci

Os números de Fibonacci são aqueles que pertencem à sequência 1, 1, 2, 3, 5, 8, 13, \cdots. Essa sequência é caracterizada pelo fato de que cada número é igual à soma dos dois anteriores.

Matematicamente, se fibo(n) for a função que gera os números de Fibonacci, então ela possui a seguinte estrutura matemática:

\begin{array}{rl} fibo(0) &= 1\\ fibo(1) &= 1 \\ fibo(n) &= fibo(n-1) + fibo(n-2) \end{array}

Um exemplo de código em C++ que exibe os números de Fibonacci é o seguinte:

#include <iostream>
 
using namespace std;
 
int fibo(int numero) {
    if (numero == 0 || numero == 1) {
        return 1;
    }
    return fibo(numero - 1) + fibo(numero - 2);
}
 
int main() {
    int x = 0, i = 0;
    cout << "Digite um número: "; cin >> x;
     
    while (i < x) {
        cout << "O número de Fibonacci na posição " << i + 1 << " é: " << fibo(i) << endl;
        i = i + 1;
    }   
}

Retorno Múltiplo em Funções

Em C++, uma função pode retornar mais de um valor utilizando estruturas como std::pair, std::tuple ou referências a variáveis.

Exemplo: Função que retorna dois valores com std::pair

#include <iostream>
#include <utility> // Para usar std::pair
using namespace std;
 
pair<int, int> dividir(int a, int b) {
    return make_pair(a / b, a % b);
}
 
int main() {
    int numerador = 0, denominador = 1;
     
    cout << "Digite o numerador: "; cin >> numerador;
    cout << "Digite o denominador: "; cin >> denominador;
     
    pair<int, int> resultado = dividir(numerador, denominador);
 
    cout << "Quociente: " << resultado.first << endl;
    cout << "Resto: " << resultado.second << endl;
 
    return 0;
}

Aqui, a função dividir() retorna dois valores: o quociente e o resto de uma divisão inteira.

Exemplo: Função que retorna dois valores com std::tuple

#include <iostream>
#include <tuple>
using namespace std;
tuple<int, int, int> operacoes(int a, int b) {
    return make_tuple(a + b, a - b, a * b);
}
int main() {
    int soma = 0, subtracao = 0, produto = 0;
    int a = 0, b = 0;
    
    cout << "Digite um número: "; cin >> a;
    
    cout << "Digite outro número: "; cin >> b;
    
    std::tie(soma, subtracao, produto) = operacoes(a, b);
    cout << "Soma: " << soma << ", Subtração: " << subtracao << ", Produto: " << produto << endl;
    return 0;
}

Sobrecarga de Funções (Overloading)

A sobrecarga de funções permite definir múltiplas funções com o mesmo nome, mas com diferentes tipos ou quantidades de parâmetros. Isso melhora a legibilidade e a reutilização do código.

#include <iostream>
#include <string> // Necessário para usar std::string
#include <cmath>
using namespace std;
// Área de um quadrado ou círculo (figuras com um único dado)
double area(double lado) {
    return lado * lado;
}
// Área de um retângulo (ou figuras com dois dados)
double area(double base, double altura) {
    return base * altura;
}
// Área de um triângulo (ou figuras com três dados)
double area(double a, double b, double c) {
    return 0.25 * sqrt((a + b + c) * (a + b - c) * (a - b + c) * (-a + b + c));
}
int main() {
    string figura;
    double resultado = 0;
    double l1 = 0, l2 = 0, l3 = 0;
    // Solicitar a figura
    cout << "Qual é a figura? (quadrado, circulo, retangulo ou triangulo): ";
    cin >> figura;
    // Avaliar a figura com if-else
    if (figura == "quadrado") {
        cout << "Qual é o tamanho do lado? "; cin >> l1;
        resultado = area(l1);
        cout << "A área do quadrado é: " << resultado << endl;
    } 
    else if (figura == "retangulo") {
        cout << "Qual é o tamanho da base? "; cin >> l1;
        cout << "Qual é o tamanho da altura? "; cin >> l2;
        resultado = area(l1, l2);
        cout << "A área do retângulo é: " << resultado << endl;
    } 
    else if (figura == "circulo") {
        l1 = 3.141592653;
        cout << "Qual é o tamanho do raio? "; cin >> l2;
        resultado = area(l1, l2);
        cout << "A área do círculo é: " << resultado << endl;
    } 
    else if (figura == "triangulo") {
        cout << "Qual é o tamanho dos lados?" << endl;
        cout << "Lado 1: "; cin >> l1;
        cout << "Lado 2: "; cin >> l2;
        cout << "Lado 3: "; cin >> l3;
            
        if ((l1 + l2 + l3) * (l1 + l2 - l3) * (l1 - l2 + l3) * (-l1 + l2 + l3) < 0) {
            cout << "O triângulo é impossível";
        }    
        else {
            resultado = area(l1, l2, l3);
            cout << "A área do triângulo é: " << resultado << endl;
        }             
    }
    else {
        cout << "Figura não válida." << endl;
    }
    return 0;
}

Funções inline em C++

As funções inline em C++ oferecem um mecanismo para otimizar o desempenho do programa, reduzindo a sobrecarga de chamadas de função. Em vez de executar uma chamada convencional, o compilador tenta expandir o código da função diretamente em cada local onde ela é invocada.

Sintaxe de uma função inline

inline tipo_de_retorno nome_da_funcao(lista_de_parametros) {
    // Corpo da função
    return valor; // Se necessário
}

Ao usar inline, eliminamos a necessidade de pular para outro endereço de memória para executar a função, o que pode reduzir o tempo de execução.

Diferenças entre uma função inline e uma função convencional

Exemplo de função inline

#include <iostream>
using namespace std;
inline int quadrado(int x) {
    return x * x;
}
int main() {
    cout << "O quadrado de 5 é: " << quadrado(5) << endl;
    return 0;
}

🔍 Processo do compilador:

1. O compilador substitui a chamada quadrado(5) diretamente por 5 * 5.
2. Não há salto de execução.
3. O cálculo é realizado na mesma linha onde a função foi chamada.

Vantagens e desvantagens de inline

✅ Vantagens

• Elimina a sobrecarga de chamadas de função: Reduz o tempo de execução em funções curtas e chamadas frequentemente.
• Facilita otimizações pelo compilador: Pode melhorar o desempenho ao evitar o uso de registradores da CPU e da pilha.
• Garante que o código da função esteja disponível em tempo de compilação.

❌ Desvantagens

• Aumenta o tamanho do binário: Se a função inline for usada muitas vezes em um programa grande, o código será duplicado em cada ponto de invocação. Isso ocorre quando usada em funções longas ou muito repetidas.
• Não garante sempre expansão inline: O compilador pode ignorar a solicitação de inline se considerar que não é a melhor opção.