EASYACM

✍️ Definindo Funções

"A definição de uma função é onde você escreve o código que será executado quando a função for chamada. Ela inclui o cabeçalho (tipo de retorno, nome e parâmetros) e o corpo (as instruções entre chaves)."

Enquanto a declaração (protótipo) informa ao compilador que uma função existe, a definição é a implementação concreta. É na definição que você coloca a lógica que resolve o problema proposto pela função.

📌 Sintaxe Completa da Definição

// Sintaxe geral: // tipo_retorno nome_da_funcao(tipo1 param1, tipo2 param2, ...) { // // corpo da função // return valor; // se o tipo de retorno não for void // } // Exemplo completo int somar(int a, int b) { // cabeçalho int resultado = a + b; // corpo inicia return resultado; // retorno } // corpo termina

📋 O Cabeçalho da Função

O cabeçalho (ou assinatura) contém todas as informações necessárias para chamar a função corretamente.

Componente	Obrigatório?	Exemplo
Tipo de retorno	✅ Sim (pode ser void)	int, double, string
Nome da função	✅ Sim	calcularMedia
Lista de parâmetros	✅ Sim (pode ser vazia: ())	(int a, int b)

📝 Nomes de Parâmetros na Definição

Na definição, os nomes dos parâmetros são obrigatórios — eles são usados dentro do corpo da função para referenciar os valores passados.

// Na declaração, nomes são opcionais int somar(int, int); // OK: apenas tipos // Na definição, nomes são obrigatórios int somar(int a, int b) { // 'a' e 'b' são usados no corpo return a + b; }

📦 O Corpo da Função

O corpo é o bloco de código entre { e }. Ele contém as instruções que implementam a lógica da função.

bool ehPar(int numero) { // O corpo pode conter declarações, loops, condicionais, etc. if (numero % 2 == 0) { return true; } else { return false; } } // Versão mais concisa bool ehParConcisa(int numero) { return numero % 2 == 0; }

📏 Variáveis Locais

Variáveis declaradas dentro do corpo da função são locais: só existem durante a execução da função e não são visíveis fora dela.

double calcularAreaCirculo(double raio) { const double PI = 3.14159; // Variável local double area = PI * raio * raio; // Outra variável local return area; } // PI e area não existem mais aqui

🔄 O Comando return

O return faz duas coisas: (1) termina a execução da função imediatamente e (2) devolve um valor ao chamador (se o tipo de retorno não for void).

// Função com múltiplos pontos de retorno int classificarNota(float nota) { if (nota >= 9.0f) return 1; // Excelente if (nota >= 7.0f) return 2; // Bom if (nota >= 5.0f) return 3; // Regular return 4; // Insuficiente } // Em funções void, return pode ser usado para sair mais cedo void imprimirSePositivo(int valor) { if (valor <= 0) { cout << "Valor não positivo" << endl; return; // Sai da função sem retornar valor } cout << "Valor: " << valor << endl; }

⚠️ Atenção! Se uma função com tipo de retorno diferente de void não encontra um return em todos os caminhos possíveis, o comportamento é indefinido. O compilador pode ou não avisar sobre isso.

📤 Parâmetros Formais vs. Argumentos Reais

É importante distinguir os termos:

Termo	Definição	Exemplo
Parâmetros formais	Variáveis declaradas no cabeçalho da função	int a, int b em somar(int a, int b)
Argumentos reais	Valores passados na chamada da função	5, 3 em somar(5, 3)

int multiplicar(int x, int y) { // x e y são parâmetros formais return x * y; } int main() { int a = 10, b = 20; int resultado = multiplicar(a, b); // a e b são argumentos reais resultado = multiplicar(5, 6); // 5 e 6 também são argumentos reais }

📋 Parâmetros com Valor Padrão (C++)

Em C++, parâmetros podem ter valores padrão, tornando-os opcionais na chamada.

// Parâmetros com valor padrão devem vir por último void saudacao(const std::string& nome, const std::string& titulo = "Sr(a)") { cout << "Olá, " << titulo << " " << nome << "!" << endl; } int main() { saudacao("Silva"); // Olá, Sr(a) Silva! saudacao("Maria", "Dra"); // Olá, Dra Maria! }

📊 Organização de Funções em Arquivos

Em projetos maiores, é comum separar declarações e definições:

• Arquivo de cabeçalho (.h ou .hpp): Contém as declarações (protótipos) das funções.
• Arquivo de implementação (.cpp): Contém as definições das funções.

// matematica.h (cabeçalho) #ifndef MATEMATICA_H #define MATEMATICA_H int somar(int a, int b); int subtrair(int a, int b); #endif // matematica.cpp (implementação) #include "matematica.h" int somar(int a, int b) { return a + b; } int subtrair(int a, int b) { return a - b; }

💡 Boas Práticas na Definição de Funções

• ✅ Mantenha funções pequenas e focadas — idealmente, uma função deve fazer apenas uma coisa.
• ✅ Use nomes descritivos que indiquem claramente o propósito da função.
• ✅ Evite muitos parâmetros (mais de 3-4 já é um sinal para reconsiderar o design).
• ✅ Prefira passar objetos grandes por referência constante para evitar cópias desnecessárias.
• ✅ Documente funções complexas com comentários explicando o que fazem, os parâmetros e o retorno.

🔗 Conclusão

Definir funções corretamente é a base para escrever código C/C++ limpo, reutilizável e de fácil manutenção. Uma boa definição de função tem um propósito claro, parâmetros bem escolhidos e um corpo conciso que implementa exatamente a lógica necessária. Ao dominar a arte de definir funções, você estará aplicando os princípios fundamentais da programação estruturada e da modularização.

📘 Capítulo 22 · Definindo Funções — Sintaxe e Implementação

⏭️ Próximo: Argumentos e tipos de retorno em funções...