Ao final desta aula, o estudante deverá ser capaz de:

• Compreender o conceito de função e a sua importância na modularização de programas em C.
• Declarar protótipos de funções e definir o seu corpo corretamente.
• Chamar funções, passando argumentos e tratando valores de retorno.
• Distinguir passagem de parâmetros por valor e por referência (ponteiros).
• Aplicar funções na construção de bibliotecas e drivers para sistemas embarcados.

Uma função é um bloco de código com um nome, que executa uma tarefa específica e pode ser chamada em qualquer parte do programa.

Em C, todo programa é uma colecção de funções. A execução começa sempre pela função main().

tipoRetorno nomeDaFuncao(tipo1 param1, tipo2 param2) {
    // corpo da função
    return valor;
}

O protótipo informa o compilador sobre a existência da função, o seu nome, tipo de retorno e parâmetros — antes de a função ser usada.

// Protótipo (termina com ponto-e-vírgula)
int  soma(int a, int b);
void ligaLed(int numero);
float media(float x, float y);

#include <stdio.h>

int soma(int a, int b);  // protótipo

int main(void) {
    printf("%d\n", soma(3, 4));
    return 0;
}

int soma(int a, int b) {
    return a + b;
}

A definição contém o corpo com os comandos que a função executa quando for chamada.

int soma(int a, int b) {
    int resultado;
    resultado = a + b;
    return resultado;
}

void desenhaLinha(void) {
    int i;
    for (i = 0; i < 10; i++) {
        printf("*");
    }
    printf("\n");
}

Para executar uma função, escreve-se o seu nome seguido de parênteses com os argumentos. O fluxo salta para a função, executa-a e volta ao ponto de chamada.

int main(void) {
    int r;
    r = soma(3, 4);  // chamada → r = 7
    desenhaLinha();      // chamada sem retorno
    return 0;
}

// Chamadas aninhadas — a função pode chamar outras funções
float mediaFinal(float a, float b) {
    return media(a, b) * 1.1;
}

Quando uma função é chamada, os valores passados são copiados para os parâmetros formais declarados na função. Este é o mecanismo padrão da linguagem C: passagem por valor.

int soma(int a, int b)
          ↑     ↑
       formais

soma(3, x);
      ↑  ↑
   reais

A função recebe uma cópia do valor do argumento. Alterações feitas dentro da função não afectam a variável original.

void duplica(int n) {
    n = n * 2;
    printf("Dentro: n = %d\n", n);
}

int main(void) {
    int x = 10;
    duplica(x);
    printf("Fora: x = %d\n", x);   // 10 (não mudou!)
    return 0;
}

Em vez de passar o valor, passamos o endereço da variável (com &). Dentro da função usamos um ponteiro para aceder e modificar o valor original (com *).

void duplica(int *n) {
    *n = (*n) * 2;
}

int main(void) {
    int x = 10;
    duplica(&x);
    printf("x = %d\n", x);   // 20
    return 0;
}

Em C, uma função devolve um único valor com return. Para devolver vários, usamos ponteiros como parâmetros de saída.

void calc(int a, int b, int *soma, int *prod) {
    *soma = a + b;
    *prod = a * b;
}

int main(void) {
    int s, p;
    calc(3, 4, &s, &p);
    printf("Soma = %d, Produto = %d\n", s, p);
    return 0;
}

void troca(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int x = 5, y = 9;
troca(&x, &y);   // x = 9, y = 5

int contadorGlobal;

void incrementa(void) {
    static int contadorLocal = 0;
    contadorLocal++;
    contadorGlobal++;
    printf("Local: %d, Global: %d\n", contadorLocal, contadorGlobal);
}

Uma biblioteca é um conjunto de funções com uma funcionalidade comum, organizada em dois ficheiros: .h (cabeçalho) e .c (implementação).

#ifndef MATH_H
#define MATH_H

int   quadrado(int x);
int   fatorial(int n);
float grausParaRad(float g);
void  raizes(float a, float b,
            float c, float *x1, float *x2);

#endif

#include "math.h"

int quadrado(int x) {
    return x * x;
}

float grausParaRad(float g) {
    return g * 2 * 3.14159 / 360;
}

#include "math.h"

int main(void) {
    printf("%d\n", quadrado(5));   // 25
    return 0;
}

Nos sistemas embarcados, as funções são usadas para abstrair o acesso ao hardware e criar camadas de software reutilizáveis.

Exemplo 1: Driver de LED

// led.h
void ledInit(int pino);
void ledOn(int pino);
void ledOff(int pino);
void ledToggle(int pino);

// led.c
void ledOn(int pino) {
    digitalWrite(pino, HIGH);
}

Exemplo 2: Leitura filtrada de sensor

void lerSensorFiltrado(int *valorFiltrado, int nAmostras) {
    long soma = 0;
    int i;
    for (i = 0; i < nAmostras; i++) {
        soma += adRead(0);
    }
    *valorFiltrado = soma / nAmostras;
}