C++: Prática: Funções Abrangente

Última atualização: 2026-08-26

Aulas anteriores cobriram vários aspectos de funções separadamente, mas em programas reais eles são usados juntos.

Nesta aula, vamos praticar fazer funções trabalharem juntas através de vários exemplos abrangentes.

1. Exemplo 1: Biblioteca Simples de Utilitários Matemáticos

(1) 1.1 Análise de Requisitos

Vamos construir uma biblioteca de utilitários matemáticos com as seguintes funções:

int add(int a, int b) — Adição
int subtract(int a, int b) — Subtração
int multiply(int a, int b) — Multiplicação
double divide(int a, int b) — Divisão (retorna ponto flutuante)
int power(int base, int exp) — Exponenciação
bool isPrime(int n) — Verificação de primo

▶ Exemplo 1: Biblioteca de Utilitários Matemáticos (Dificuldade ⭐⭐)

CPP 📖 Somente leitura

#include <iostream>
#include <cmath>

// Protótipos de funções
int add(int a, int b);
int subtract(int a, int b);
int multiply(int a, int b);
double divide(int a, int b);
int power(int base, int exp);
bool isPrime(int n);

int main() {
	int x = 10, y = 3;
	
	std::cout << "x + y = " << add(x, y) << std::endl;
	std::cout << "x - y = " << subtract(x, y) << std::endl;
	std::cout << "x * y = " << multiply(x, y) << std::endl;
	std::cout << "x / y = " << divide(x, y) << std::endl;
	std::cout << "x ^ y = " << power(x, y) << std::endl;
	std::cout << "Is x prime? " << (isPrime(x) ? "Yes" : "No") << std::endl;
	
	return 0;
}

// Definições de funções
int add(int a, int b) {
	return a + b;
}

int subtract(int a, int b) {
	return a - b;
}

int multiply(int a, int b) {
	return a * b;
}

double divide(int a, int b) {
	if (b == 0) {
		return 0.0;
	}
	return static_cast<double>(a) / b;
}

int power(int base, int exp) {
	if (exp < 0) {
		return 0; // Simplificado: expoentes negativos não suportados
	}
	int result = 1;
	for (int i = 0; i < exp; i++) {
		result *= base;
	}
	return result;
}

bool isPrime(int n) {
	if (n <= 1) {
		return false;
	}
	for (int i = 2; i * i <= n; i++) {
		if (n % i == 0) {
			return false;
		}
	}
	return true;
}

52 linhas de lógica (limite de 40, somente leitura)

Saída:

TEXT 📖 Somente leitura

x + y = 
x - y = 
x * y = 
x / y = 
x ^ y = 
Is x prime? YesNo

Execução de exemplo:

TEXT 📖 Somente leitura

x + y = 13
x - y = 7
x * y = 30
x / y = 3.33333
x ^ y = 1000
Is x prime? No

2. Exemplo 2: Jogo de Adivinhação de Números (Versão com Funções)

(1) 2.1 Análise de Requisitos

Reescrever o jogo de adivinhação anterior usando funções:

void printWelcome() — Imprimir mensagem de boas-vindas
int getSecretNumber() — Gerar número secreto
int getGuess() — Obter palpite do usuário
void printResult(int guess, int secretNumber) — Imprimir resultado (muito alto/muito baixo/correto)
void playGame() — Lógica principal do jogo

▶ Exemplo 2: Jogo de Adivinhação de Números (Versão com Funções) (Dificuldade ⭐⭐)

CPP 📖 Somente leitura

#include <iostream>
#include <cstdlib>
#include <ctime>

// Protótipos de funções
void printWelcome();
int getSecretNumber();
int getGuess();
void printResult(int guess, int secretNumber);
void playGame();

int main() {
	std::srand(static_cast<unsigned int>(std::time(nullptr)));
	
	char playAgain;
	do {
		playGame();
		std::cout << "Want to play again? (y/n): ";
		std::cin >> playAgain;
	} while (playAgain == 'y' || playAgain == 'Y');
	
	std::cout << "Thanks for playing, goodbye!" << std::endl;
	return 0;
}

// Definições de funções
void printWelcome() {
	std::cout << "=========== Number Guessing Game ===========" << std::endl;
	std::cout << "I'm thinking of a number from 1-100, guess it!" << std::endl << std::endl;
}

int getSecretNumber() {
	return std::rand() % 100 + 1;
}

int getGuess() {
	int guess;
	std::cout << "Enter your guess: ";
	std::cin >> guess;
	return guess;
}

void printResult(int guess, int secretNumber) {
	if (guess > secretNumber) {
		std::cout << "Too high! Try again." << std::endl;
	} else if (guess < secretNumber) {
		std::cout << "Too low! Try again." << std::endl;
	} else {
		std::cout << "🎉 Congratulations! You got it!" << std::endl;
	}
}

void playGame() {
	printWelcome();
	int secretNumber = getSecretNumber();
	int guess;
	int attempts = 0;
	
	do {
		guess = getGuess();
		attempts++;
		printResult(guess, secretNumber);
	} while (guess != secretNumber);
	
	std::cout << "You guessed " << attempts << " times." << std::endl << std::endl;
}

50 linhas de lógica (limite de 40, somente leitura)

Saída:

TEXT 📖 Somente leitura

Want to play again? (y/n):
Thanks for playing, goodbye!
=========== Number Guessing Game ===========
I'm thinking of a number from 1-100, guess it!
Enter your guess:
Too high! Try again.
Too low! Try again.
🎉 Congratulations! You got it!
You guessed  times.

3. Exemplo 3: Calculadora Simples (Versão com Sobrecarga de Funções)

(1) 3.1 Análise de Requisitos

Implementar uma calculadora usando sobrecarga de funções, suportando tipos int e double.

▶ Exemplo 3: Calculadora (Versão com Sobrecarga de Funções) (Dificuldade ⭐⭐)

CPP

#include <iostream>
#include <iomanip>

// Protótipos de funções (sobrecarregadas)
int calculate(int a, int b, char op);
double calculate(double a, double b, char op);

int main() {
	int intResult = calculate(10, 3, '+');
	double doubleResult = calculate(10.0, 3.0, '/');
	
	std::cout << "10 + 3 = " << intResult << std::endl;
	std::cout << std::fixed << std::setprecision(2);
	std::cout << "10.0 / 3.0 = " << doubleResult << std::endl;
	
	return 0;
}

// Definições de funções (sobrecarregadas)
int calculate(int a, int b, char op) {
	switch (op) {
	case '+': return a + b;
	case '-': return a - b;
	case '*': return a * b;
	case '/': return a / b; // Divisão inteira
	default: return 0;
	}
}

double calculate(double a, double b, char op) {
	switch (op) {
	case '+': return a + b;
	case '-': return a - b;
	case '*': return a * b;
	case '/': return b != 0 ? a / b : 0.0;
	default: return 0.0;
	}
}

▶ Experimente

Saída:

TEXT 📖 Somente leitura

10 + 3 = 
10.0 / 3.0 =

4. Exercício Prático: Gerenciamento de Notas de Alunos (Versão com Funções)

▶ Exemplo 4: Gerenciamento de Notas de Alunos (Dificuldade ⭐⭐⭐)

CPP 📖 Somente leitura

#include <iostream>
#include <string>

// Protótipos de funções
void printMenu();
void addStudent(std::string names[], int scores[], int& count);
void printStudents(const std::string names[], const int scores[], int count);
double calculateAverage(const int scores[], int count);
int findMaxScore(const int scores[], int count);

int main() {
	const int MAX_STUDENTS = 100;
	std::string names[MAX_STUDENTS];
	int scores[MAX_STUDENTS];
	int count = 0;
	
	int choice;
	do {
		printMenu();
		std::cout << "Choose (1-4): ";
		std::cin >> choice;
		
		if (choice == 1) {
			addStudent(names, scores, count);
		} else if (choice == 2) {
			printStudents(names, scores, count);
		} else if (choice == 3) {
			if (count == 0) {
				std::cout << "No student data!" << std::endl;
			} else {
				std::cout << "Average: " << calculateAverage(scores, count) << std::endl;
				std::cout << "Highest score: " << findMaxScore(scores, count) << std::endl;
			}
		} else if (choice == 4) {
			std::cout << "Goodbye!" << std::endl;
		} else {
			std::cout << "Error: Please enter a number between 1-4!" << std::endl;
		}
		
		std::cout << std::endl;
		
	} while (choice != 4);
	
	return 0;
}

// Definições de funções
void printMenu() {
	std::cout << "=========== Student Grade Management ===========" << std::endl;
	std::cout << "1. Add student" << std::endl;
	std::cout << "2. Show all students" << std::endl;
	std::cout << "3. Statistics" << std::endl;
	std::cout << "4. Exit" << std::endl;
}

void addStudent(std::string names[], int scores[], int& count) {
	if (count >= 100) {
		std::cout << "Maximum number of students reached!" << std::endl;
		return;
	}
	
	std::cout << "Enter name: ";
	std::cin.ignore();
	std::getline(std::cin, names[count]);
	
	std::cout << "Enter score: ";
	std::cin >> scores[count];
	
	count++;
	std::cout << "Added successfully!" << std::endl;
}

void printStudents(const std::string names[], const int scores[], int count) {
	if (count == 0) {
		std::cout << "No student data!" << std::endl;
		return;
	}
	
	std::cout << "=========== Student List ==========" << std::endl;
	for (int i = 0; i < count; i++) {
		std::cout << i + 1 << ". " << names[i] << " - " << scores[i] << std::endl;
	}
}

double calculateAverage(const int scores[], int count) {
	if (count == 0) {
		return 0.0;
	}
	
	int sum = 0;
	for (int i = 0; i < count; i++) {
		sum += scores[i];
	}
	
	return static_cast<double>(sum) / count;
}

int findMaxScore(const int scores[], int count) {
	if (count == 0) {
		return 0;
	}
	
	int maxScore = scores[0];
	for (int i = 1; i < count; i++) {
		if (scores[i] > maxScore) {
			maxScore = scores[i];
		}
	}
	
	return maxScore;
}

87 linhas de lógica (limite de 40, somente leitura)

Saída:

TEXT 📖 Somente leitura

Choose (1-4):
No student data!
Average:
Highest score:
Goodbye!
Error: Please enter a number between 1-4!
=========== Student Grade Management ===========
1. Add student
2. Show all students
3. Statistics
4. Exit
Maximum number of students reached!
Enter name:
Enter score:
Added successfully!
No student data!
=========== Student List ==========
.  -

❓ Perguntas Frequentes

P: Quão longa deve ser uma função? R: Uma função deve fazer apenas uma coisa.

Se uma função é muito longa (ex.: mais de 30 linhas), considere dividi-la em múltiplas funções menores.

Regra prática: Se você não consegue descrever concisamente o que uma função faz pelo seu nome, ela está fazendo demais.

P: Quando devo escrever código como uma função? R:> - Código é repetido 2+ vezes → escreva uma função > - Um bloco de código tem um propósito claro → escreva uma função (melhora legibilidade) > - Precisa ser reutilizado → escreva uma função P: Protótipos de funções são obrigatórios? R: Se a definição da função vem antes de main, você não precisa de protótipo.

Mas é recomendado sempre escrever protótipos de funções — assim main pode ser colocado primeiro, tornando a estrutura do programa mais clara.

📖 Resumo

Em programas reais, funções trabalham juntas
Divida problemas grandes em funções pequenas, cada uma fazendo uma coisa
Use protótipos de funções para declarações, definições de funções para implementação
Sobrecarga de funções permite funções com o mesmo nome lidar com tipos diferentes
Boa nomenclatura de funções torna o código auto-documentado

📝 Exercícios

Básico (Dificuldade ⭐): Reescreva o programa anterior "calcular área do retângulo" como uma versão com função:
1. Escreva uma função double calculateArea(double width, double height)
2. Chame-a em main
Intermediário (Dificuldade ⭐⭐): Escreva um programa com as seguintes funções: 3. int fibonacci(int n) — Retorna o n-ésimo número de Fibonacci 4. void printFibonacci(int n) — Imprime os primeiros n termos 5. Em main, permita que o usuário insira n e chame essas duas funções
Desafio (Dificuldade ⭐⭐⭐): Estenda o programa "Gerenciamento de Notas de Alunos" com as seguintes funcionalidades: 6. Excluir aluno (por nome ou índice) 7. Ordenar por nota (do maior para o menor) 8. Salvar em arquivo / Carregar de arquivo (opcional)

Encapsulamento de funções melhora legibilidade e reutilização do código
Arrays decaem para ponteiros quando passados como parâmetros de função
Composição de funções: uma função chamando outra
Aplicações comuns de recursão: fatorial, Fibonacci, exponenciação
Arquitetura do programa: entrada → processamento → saída, cada passo encapsulado em uma função

5. 🚀 Próximos Passos

Parabéns! Você completou todas as aulas da Fase 2 (Funções). A seguir, entramos na Fase 3 (Arrays, Strings, Structs), aprendendo como lidar com múltiplos valores do mesmo tipo e strings do C++.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós