Funções

Rafael
rafaelbba@gmail.com
Programas simples:
sequência de instruções para resolver um problema, formadas por
estruturas de controle (sequencial, seleção e repetição).

Programas complexos:
- Variedade de situações a serem resolvidas

- Grande quantidade de instruções em um único bloco afetam a

legibilidade e entendimento do programa.

Solução: utilizar uma estrutura que explicite as pequenas

soluções  Modularização

“Dividir para conquistar”

Vantagens da Modularização
•Facilita a construção de grandes programas através da divisão em pequenas etapas:

módulos (subrotinas ou subprogramas)

•Permite que trechos do programa possam ser reutilizados em diferentes partes do

programa ou em novos programas

•As partes do programa podem ser escritas e testadas separadamente

•Pode suprimir detalhes e particularidades da implementação do bloco principal .

•Analogia: Terceirização / Refrão de Música

Na linguagem C: Função

É um trecho de código de um programa projetado para cumprir

uma tarefa específica, que pode ou não retornar um valor.

- pode estar no mesmo arquivo ou em arquivos separados

O uso de função envolve três passos:

•Declaração (protótipo) – antes do main( )
•Definição (código da função) – depois do main( )
•Ativação (chamada): dentro do main( ) ou de uma outra função
Funções

Sintaxe da Declaração (Protótipo da função):

tipo nome_da_função (lista_de_parâmetros);

tipo é o tipo da informação retornada da função;

•se a função não retornar nada, seu tipo deve ser void

parâmetros: lista de tipos (e variáveis) que serão

passados como argumentos para a função;
•pode ser vazio!

Exemplo:

int soma (int a, int b);

void imprimeSoma(int a, int b);
int anoAtual ();
Funções

Sintaxe da Definição:
tipo nome_da_função (lista_de_parâmetros){
declaração de variáveis;
comandos;
return (expressão); /*opcional*/
}
- o return serve para indicar o valor a ser retornado, se
for o caso.
Exemplo:
int soma (int a, int b){
int resultado;
resultado = a + b;
return (resultado);
}
Funções

Ativação sem retorno de valor:

nome_da_função (parâmetros);

Formas de Ativação com retorno de valor:

Exemplos:
• variável = nome_da_função(parâmetros);
• if (nome_da_função(parâmetros) < 100)...
• while (nome_da_função(parâmetros) < 10)...
• printf(“o valor é: %d”,nome_da_função(parâmetros));
Funções

• A ativação faz com que o controle seja transferido para

o trecho chamado (primeira instrução) e executa até o
fim do trecho (última instrução)
•Ao final da função, o controle volta para instrução
seguinte à chamada

main( ) float calculo( )

{ {
....... <1a. instrução> primeira
<2a. instrução>
A = calculo( ); .......
A= A+1; <última instrução> última
....... }
}
Variáveis e Funções
Uma função pode fazer referência a variáveis:

- declaradas localmente:
variáveis locais da unidade

- declaradas globalmente:
variáveis globais do programa

Obs: A função não pode acessar as variáveis declaradas

localmente no programa principal.
Variáveis Locais

Espaço de memória é alocado na entrada da

execução da função e liberado na saída
Só podem ser usadas pela função à qual
pertencem

São variáveis automáticas: o valor é perdido

quando a função termina  não guardam o valor
anterior
Variáveis Globais

•Declaradas fora das funções

•Podem ser usadas em qualquer função
•Devem ficar no início do arquivo, antes da
declaração da função main( )

Não é uma boa prática de programação

ATENÇÃO: O trabalho final da disciplina não

pode ser implementado com variável global!!!
Comando Return

•Retorna o resultado para o trecho do programa que

chamou a função, podendo ser:
-atribuído a uma variável
-usado em algum comando
-fazer parte de alguma expressão.
variável = nome_da_função(parâmetros);
if (nome_da_função(parâmetros) < 100)...
while (nome_da_função(parâmetros) < 10)...
printf(“o valor é: %d”,nome_da_função(parâmetros) );

•Causa uma saída imediata da função na qual ele se

encontra, fazendo com que a execução retorne para o
ponto do programa que chamou a função
•Pode aparecer mais de uma vez na função (sendo que
apenas um será executado a cada ativação do módulo)
- Exemplos nos próximos slides.
Parâmetros

A transferência de informações para os módulos pode ser

feita através de:
- Variáveis Globais:
Deve ser feito com critério, pois pode gerar um alto grau de
dependência entre as funções, dificultando manutenção e reutilização.

-Parâmetros:
- -> Existem dois tipos de passagem de parâmetros:
a) Passagem por valor
b) Passagem por referência
Tipos de Passagem

1) Por Valor
o valor do parâmetro original é atribuído ao parâmetro
na função

- cada parâmetro se comporta como uma variável local,

inicializada com o valor passado na chamada
- o nome da variável na função pode ser igual ao nome
da variável de origem ou não
- as alterações nos parâmetros da função (variáveis
locais) não têm efeito sobre os parâmetros originais
Tipos de Passagem

Por Valor (cont):

- execução funciona com o modelo de pilha
- cada variável local é colocada na pilha de execução no
momento da chamada à função
- os parâmetros são copiados para a pilha e
tratados como variáveis locais
- quando a função termina, a parte da pilha
correspondente àquela função é liberada (por isso
as variáveis locais não são acessíveis de fora da
função)
Passagem por Valor

Esquema da memória
- representação simplificada
- nomes à esquerda representam os nomes das variáveis
números à direita representam as posições da memória
(endereços) Pilha

Exemplos (nos próximos slides)

Fatorial
Potência
c 'casa' 210

b 85.3 206

a 4 202
Fatorial (Passagem por Valor) O valor de n de main não é
#include <stdio.h> alterado pelas operações
int fat (int n); realizadas em n local dentro da
main( ) { função
int n, r;
scanf("%d", &n);
r=fat(n);
printf("Fatorial de %d = %d\n", n, r);
}
int fat (int n) { A variável n, que representa o
int f=1;
while (n) { parâmetro da função fat, é local
f*=n; a este módulo e não representa
n--; a variável n da função main
}
return f;
}
 #include <stdio.h>
int fat (int n);
main( ) {
int n, r;
scanf("%d", &n);
Passagem por Valor r=fat(n);
printf("Fatorial de %d = %d\n", n, r);
}
Passo a passo no Exemplo do Fatorialint fat (int n) {
int f=1;
while (n) {
f*=n;
n--;
}
return f;
}

n 5
fat >
r - r -
n 5 n 5
main > main > main >

f 1 f 120
fat >
n 5 fat >
n 0
r - r - r 120
main >
n 5 main >
n 5 main >
n 5
Potência (Passagem por Valor)

#include <stdio.h>
int potencia (int b, int e);
main( ) {
int p, x, y;
printf("Informe base e expoente\n");
scanf("%d", &x);
scanf(“%d", &y);
p=potencia(x, y);
printf("Resultado = %d\n", p);
}
int potencia(int b, int e){
int i, pot=1;
for (i=1; i<=e; i++)
pot=pot * b;
return pot;
}
Exercícios (NÃO USE VARIÁVEL GLOBAL)
1. Faça um programa que leia dois valores inteiros e crie uma função
para imprimir a diferença entre o primeiro valor e o segundo valor lido.

2. Faça um programa que leia os coeficientes (a, b, c) de uma equação

do segundo grau, e crie uma função para calcular e exibir o valor de
seu discriminante, = b2 -4ac.

3. Elabore um programa que leia três números inteiros e crie uma função
que retorne o maior entre eles para ser impresso pelo programa
principal.

4. Faça um programa que utiliza duas funções. Umas para converter

uma temperatura de Fahrenheit para Celsius. E outra para converter
de Celsius para Fahrenheit. Lembrando que: C=(5/9)*(F-32).

5. Escreva um programa que leia um inteiro N, e crie uma função que

leia uma sequência de N números inteiros, e imprime a soma dos
números pares da sequência lida.
Tipos de Passagem

2) Por Referência:
o endereço (localização) na memória do parâmetro
de origem é transferido para parâmetro da função e
a função usa o elemento original em suas operações
(mesmo que com um identificador diferente)
permite alterar os valores das variáveis acessando-as
indiretamente

Passagem por referência utiliza PONTEIRO

Já utilizávamos ponteiro:
scanf(“%d”, &nota1);
Exemplo

/* função para trocar variáveis ( ERRADA) */

#include <stdio.h>
void troca (int x, int y);
main( ) {
int a=5, b=8;
printf("A = %d \t B = %d\n",a, b);
troca(a, b);
printf("A = %d \t B = %d\n",a, b);
}
void troca (int x, int y) {
int aux;
aux=x;
x=y;
y=aux;
}
Exemplo

/* função para trocar variáveis (CORRETA) */

#include <stdio.h>
void troca (int *px, int *py);
main( ) {
int a=5, b=8;
printf("A = %d \t B = %d\n",a, b);
troca(&a, &b);
printf("A = %d \t B = %d\n",a, b);
}
void troca (int *px, int *py) {
int aux;
aux=*px;
*px=*py;
*py=aux;
}
 main( ) { void troca (int *px, int *py) {
int a=5, b=8; int aux;
printf("A = %d \t B = %d\n",a, b);
troca(&a, &b); aux=*px;
Exemplo printf("A = %d \t B = %d\n",a, b); *px=*py;
} *py=aux;
Passo a passo na memória }

aux - 218
206
py 214 py 206 214
210 px 202 210 px 202 210
troca > troca >
b 8 206 b 8 206 b 8 206

main >
a 5 202
main >
a 5 202
main >
a 5 202

aux 5 218 aux 5 218 aux 5 218

py 206 214 py 206 214 py 206 214
px 202 210 px 202 210 px 202 210
troca > troca > troca >
b 8 206 b 8 206 b 5 206

main >
a 5 202
main >
a 8 202
main >
a 8 202
Exemplo

Passo a passo na memória

aux -
5 218
py 206 214
px 202 210
troca >
b 5
8 206
a 8
5 202
main >
Vetores e Funções
Vetores e Funções

Passagem de vetor como parâmetro é feita

sempre por Referência
Os elementos do vetor nunca são copiados para a
função
Exemplo: Preencher um vetor de números reais
com 8 posições e criar uma função que retorna a
média dos elementos do vetor

Neste caso, é passado o endereço da primeira

posição do vetor
A função chamada deve ter um parâmetro do tipo
ponteiro para receber o endereço
Exemplo 1
/* Cálculo da média de 8 números reais em um vetor */
#include <stdio.h>
float media (float v[]);
int main( ) {
float vet[8],res;
int i;
for (i=0 ; i<8; i++) {
scanf("%f", &vet[i]);
}
res=media(vet);
printf("Media dos 8 números = %f \n" , res);
return 0;
}
float media (float v[]) {
int i;
float soma=0;
for (i=0 ; i<8; i++) {
soma = soma + v[i];
}
return (soma/8);
}
Vetores e Funções

Relembrando:
- a passagem de vetor como parâmetro é feita sempre por Referência.
- os elementos do vetor nunca são copiados para a função.

Neste caso, é enviado o endereço da primeira posição do vetor

A função chamada deve ter um parâmetro do tipo ponteiro para receber o
endereço
Vetores e Funções

Exemplo:
Preencher dois vetores de números reais,
um com 8 posições e um com 6 posições.
Criar uma única função que retorna a média
dos elementos de cada vetor.
Isso é possível?

Passar o tamanho do vetor

também como parâmetro
Exemplo 1
/* Cálculo da média de 8 números reais e de 6 números reais */
#include <stdio.h>
float media (int n, float v[]);
int main( ) {
float v1[8], v2[6];
int i;
for (i=0 ; i<8; i++)
scanf("%f", &v1[i]);
printf("Media dos 8 numeros = %f \n", media(8, v1));
for (i=0 ; i<6; i++)
scanf("%f", &v2[i]);
printf("Media dos 6 numeros = %f \n", media(6, v2));
return 0;
}
float media (int n, float v[]) {
int i;
float soma=0;
for (i=0 ; i<n; i++)
soma += v[i];
return soma/n;
}
Exemplo 2

/* Acrescentar 1 unidade em cada um dos 8 elementos do vetor

*/
#include <stdio.h>
void adiciona (float k[], int n); //k = vetor e n = tamanho do vetor
main( ) {
float v[8];
int i;
for (i=0 ; i<8; i++)
scanf("%f", &v[i]);
adiciona(v, 8);
printf("\n Novos valores: \n");
for (i=0 ; i<8; i++)
printf("%f \t", *(v+i));//acesso utilizando o endereço
}
void adiciona (float k[], int n) {
int i;
for (i=0 ; i<n; i++)
k[i]++;
}
Exemplo 3 e 4
/* Funções para preencher e imprimir um vetor */
#include <stdio.h>
void preencheVetor(int *vet);
void imprimeVetor(int *vet); //Vetor também funciona com *
int main( ) { //exemplo de string
int vet[8], i; #include <stdio.h>
preencheVetor(vet);
#include <string.h>
imprimeVetor(vet);
return 0;
void preencheString(char *texto);
}
void preencheVetor(int *vet) {
int i; int main( ) {
for (i=0 ; i<8; i++) { char texto[100];
scanf("%d", &vet[i]); preencheString(texto);
} printf("O valor digitado é: %s", texto);
} return 0;
void imprimeVetor(int *vet) { }
int i;
for (i=0 ; i<8; i++) { void preencheString(char *texto){
printf("%d " , vet[i]); printf("Digite uma frase:");
} fgets(texto, 100, stdin);
}
}
Exemplo 5 - Matriz
void preencheMatriz(int mat[][2]) {
/* Funções para preencher e imprimir int i, j;
uma matriz*/ for (i=0 ; i<2; i++) {
for (j=0 ; j<2; j++) {
#include <stdio.h>
scanf("%d", &mat[i][j]);
void preencheMatriz(int mat[][2]); }
void imprimeMatriz(int mat[][2]); }
}
void imprimeMatriz(int mat[][2]) {
int main( ) { int i,j;
int mat[2][2]; for (i=0 ; i<2; i++) {
preencheMatriz(mat); for (j=0 ; j<2; j++) {
printf("%d " , mat[i][j]);
imprimeMatriz(mat); }
return 0; printf("\n");
} }
}
36

Exercício
1) Faça um programa que leia um número inteiro do teclado, e implemente
uma função para verificar se esse número é par ou impar.

2) Faça um programa que crie uma matriz 3x3, e crie uma função para o
usuário preencher essa matriz e outra função que devolva a soma da diagonal
principal.

3) Faça um programa que crie um vetor de 10 posições, e implemente uma

função para preencher esse vetor e outra função para imprimir o vetor.

4) Faça um programa que crie um vetor A de inteiros com 5 posições.

Implemente as 3 funções abaixo:
- função que devolva um número aleatório. Ex:
int getRandom()
X = getRandom()
- função que receba o vetor A, e preencha com números aleatórios .
- função que receba o vetor e devolva o maior elemento.