Funções

• Uma função agrupa uma sequência de instruções com um nome
• Cada função pode receber argumentos e retornar um valor
• Cada função é um sub-programa com as suas declarações e instruções próprias

Objetivo

• Dividir o programa em componentes separadas
  • cada função tem um objetivo bem identificado
  • argumentos e resultados esperados bem definidos
• Podem ser desenvolvidas e estudadas independentemente
• Podem ser testadas separadamente
• Podem ser re-utilizadas em diferentes programas

Exemplo

Uma função que calcula a média aritmética de dois valores:

float media(float a, float b)
{ 
   float m = (a + b) / 2.0;
   return m;
}

• O identificador da função é media
• O tipo float antes do identificador indica o tipo do resultado
• Os parâmetros a e b são os dois valores de tipo float que devem fornecidos para executar a função

Corpo da função

O corpo da função está delimitado entre chavetas:

{
   float m = (a + b) / 2.0;
   return m;
}

• calcula o valor de média (usando uma variável auxiliar m)
• a instrução return termina a função e devolve o resultado ao contexto onde a função foi chamada

Invocação da função

Um expressão: identificador(arg1, arg2, ...)

Fluxo de execução

• A execução do programa começa pelo main
• main pode chamar outra função e assim sucessivamente
• Apenas são executadas as funções chamadas pelo main (direta ou indirectamente)
• Os argumentos passados a funções podem ser quaisquer expressões do tipo válido

    z = media(x*0.5, y+1);

• Podemos usar o resultado imediatamente em vez de o guardar numa variável

    printf("%f\n", media(x*0.5,y+1));

Exemplo: calcular médias

Vamos escrever um programa que lê três números e calcula as médias dois a dois.

Introduza 3 números: 3.5 9.6 10.2
Médias
3.5 e 9.6: 6.55
9.6 e 10.2: 9.9
3.5 e 10.2: 6.85

#include <stdio.h>

float media(float a, float b) {
  float m = (a + b)/2;
  return m;
}

int main(void) {
  float x, y, z;
  printf("Introduza 3 números: ");
  scanf("%f %f %f", &x, &y, &z);
  printf("Médias\n");
  printf("%f e %f: %f\n", x, y, media(x,y));
  printf("%f e %f: %f\n", y, z, media(y,z));
  printf("%f e %f: %f\n", x, z, media(x,z));
  return 0;
}

Declarações e definições

• Se colocarmos a definição da função antes do seu uso não temos de declarar mais nada
• Mas se usarmos a função antes da definição devemos colocar uma declaração de protótipo:

    float media(float, float);

• Em C89/90: se usarmos uma função sem a declararmos o compilador assume que retorna int
• Em C99: usar uma função antes da definição ou declaração resulta num erro de compilação

Exemplo

float media(float, float); // protótipo

int main(void) {
 ...
 printf(..., x, y, media(x,y));   // uso
 ...
 return 0;
 }

float media(float a, float b) {  // definição
   m = (a + b)/2.0;
   return m;
}

Funções sem valor de retorno

• Por vezes podemos querer definir funções que não retornam um valor
• Executamo-las apenas pelos seus efeitos colaterais
  • e.g. imprimir mensagems na saida-padrão
• Nesse caso o tipo do resultado é void
• Não necessitamos de return
• Não usamos o resultado

Exemplo

void print_time(int n)
{
  printf("T minus %d and counting\n", n);
}

int main(void) {
    print_time(3);
    print_time(2);
    print_time(1);
    return 0;
}

Instrução return

• Uma função com tipo diferente de void deve usar a instrução return para especificar o resultado
• A forma geral é:
  
  return expressão ;
  
  
• Não são necessário parêntesis à volta da expressão
• Por vezes a expressão é uma constante ou variável, mas pode ser uma expressão complexa:

  return 0;
  return n;
  return (x + y) / 2.0;

Instrução return

Podemos usar return para terminar a execução da função a meio do corpo.

int max(int a, int b)
{
   if(a >= b)
       return a;  // termina imediatamente
           
   // se a execução chegar a este ponto,
   // então a < b; logo o máximo é b
   return b;
}

Instrução return

• Também podemos usar return em funções que não retornam resultados (void)
• Nesse caso return serve apenas para terminar a execução da função
• Omitimos a expressão

void print_time(int n)
{
    if (n < 0)
        return;   // terminar imediatemente
    printf("T minus %d and counting\n", n);
}

Quando usar múltiplos return

• Usar múltiplos return pode dificultar a compreensão do fluxo de execução
• Recomendação: usar apenas para terminar uma função em casos especiais (e.g. de erro)

Passagem de argumentos

• Os argumentos das funções em C são passados por valor
  • cada expressão é avaliada e o seu valor é copiado para um parâmetro local à função
• Logo, os parâmetros de funções comportam-se como variáveis temporárias
  • modificações dos argumentos não são visíveis depois do retorno da função

Exemplo 1

// máximo de 2 valores
// NB: modifica o primeiro argumento
int max(int a, int b) {
    if (b > a)
        a = b;
    return a;
}

int main(void) {
   int x = 1, y = 2;
   printf("%d\n", max(x,y)); // imprime 2
   printf("%d %d\n", x, y); // imprime 1, 2
   return 0;
}

Exemplo 2

// Tenta trocar os valores de a, b;
// não funciona porque a,b são temporários
void trocar(int a, int b) {
   int t;
   t = a;
   a = b;
   b = t;
}

int main(void) {
   int x = 1, y= 2;
   trocar(x, y);  
   printf("%d %d\n", x, y); // imprime 1, 2
   return 0;
}

Decomposição funcional

• As funções permitem decompor problemas em partes mais simples
• Objetivo: combinar as partes para resolver o problema original
  • analogia: peças de Lego
• Esta metodologia de "dividir para conquistar" permite construir programas simultaneamente elegantes e eficientes

Exemplo: imprimir algarismos

Escrever um programa que imprime os algarismos das dezenas e unidades de um inteiro até 99.

Exemplos de execução:

12
um dois 

78
sete oito 

7
zero sete

Sub-problema

Dado o valor de um algarismo de 0–9, imprimir o texto correspondente em português:

Função auxiliar

Vamos definir uma função auxiliar:

void imprime_algarismo(int a);

• o argumento é um inteiro (o valor do algarismo)
• a função imprime o texto e não retorna um valor útil (resultado void)

Função auxiliar

void imprime_algarismo(int a) {
  if (a == 0)
    printf("zero");
  else if (a == 1)
    printf("um");
  else if (a == 2)
    printf("dois");
  else if (a == 3)
    printf("três");
  else if (a == 4)
    printf("quatro");

(continua no slide seguinte)

(continuação do slide anterior)

  else if (a == 5)
    printf("cinco");
  else if (a == 6)
    printf("seis");
  else if (a == 7)
    printf("sete");
  else if (a == 8)
    printf("oito");
  else if(a == 9)
    printf("nove");
  else 
    printf("algarismo inválido!");
}

Solução do problema original

• Usar a função auxiliar duas vezes:
  • imprimir o algarismo das dezenas
  • imprimir o algarismos das unidades
• Podemos obter estes algarismos usando divisões sucessivas por 10
• Se n é um inteiro entre 0 e 99:
  • n%10 é são as unidades;
  • n/10 remove unidades; restam as dezenas

Função principal

int main(void) {
  int n, d, u;
  scanf("%d", &n);
  if (!(n>=0 && n<=99)) {
     printf("número inválido\n");
     return -1;  // erro
  }
  u = n % 10;  // unidades (0..9)
  d = n / 10;  // dezenas (0..9)
  imprime_algarismo(d); printf(" ");
  imprime_algarismo(u); printf("\n");
  return 0;      // OK
}

Observações

• O programa principal fica bastante simples — apenas calcula os algarismos e executa a função
• É fácil modificar o programa
  • exemplo: imprimir também o algarismo das centenas
• Também podemos melhorar a implementação da função
  • nas aulas seguintes iremos ver alternativas à "cascata" de ifs

Conclusão

A decomposição em funções permitiu:

• escrever programas em partes mais simples
• considerar parte do problema de cada vez
• combinar as soluções para resolver o problema original