Algoritmos e

Estruturas de Dados I

Funções

Matheus Carvalho Viana

[email protected]
Introdução
Muitos programas podem abordar domínios que englobam diferentes processos.
Por exemplo, um programa para um supermercado deve tratar de produtos, fornecedores,
estoque, clientes, funcionários, venda, forma de pagamento, entrega, etc.
Para cada uma dessas entidades existem diversas ações que podem ser realizadas.
Escrever um programa como esse em um única unidade de código é extremamente
problemático, pois:
• A unidade de código terá muitas linhas de código;
• Será difícil de ler e entender;
• Será difícil de fazer manutenção.

2
Introdução
Além disso há outro problema. Imagine um programa que solicita um número e calcula o
fatorial. Depois, pede outro número e calcula a soma de zero até ele, em seguida, pede
outro número e calcula o fatorial.
#include<stdio.h> for (int i = b; i > 0; i--)
soma += i;
void main() { printf("Soma: %d\n", soma);
int a, b, c;
printf("Digite um inteiro: "); printf("Digite um inteiro: ");
scanf("%d", &a); scanf("%d", &c); Qual o
int fat = 1; fat = 1; problema
for (int i = a; i > 1; i--) for (int i = c; i > 1; i--) desse
fat *= i; fat *= i;
código?
printf("Fatorial: %d\n", fat); printf("Fatorial: %d\n", fat);
}
printf("Digite um inteiro: ");
scanf("%d", &b);
int soma = 0;
3
Introdução
O problema do exemplo anterior é a repetição do código referente ao cálculo do fatorial.

Código repetido no programa tem as seguintes consequências:

• Aumento do tamanho do programa;
• Diminuição da legibilidade do programa;
• Aumento da dificuldade de escrita;
• Dificuldade na alteração: caso seja necessário alterar o código repetido, é preciso fazer
isso em todos os lugares que ele aparece.

4
Introdução
Um problema complexo, difícil de entender e resolver como um todo, pode ser dividido em
um conjunto de problemas mais simples de entender e resolver.

Com base nessa abordagem, os programas podem ser divididos em diversas funções que
resolvem problemas menores e juntas implementação a solução para todo o programa.

Cada função pode ser utilizada diversas vezes, portanto, a solução é implementada um
única vez e pode ser reutilizada sempre que necessária em um trecho do programa.

5
Introducão
Algumas funções já vem sendo bastante utilizadas nos programas, por exemplo, as funções
provenientes da biblioteca stdio.h.
Além disso, já estamos acostumados a criar a função main.

#include<stdio.h>
Mesmo em um programa minúsculo, repare
void main() { quantas vezes as funções printf e scanf foram
int a; usadas. Se tivéssemos que implementar o código
char c; delas a cada uso, o tamanho do programa
aumentaria bastante.
printf("Digite um char: ");
scanf("%c", &c); Além disso, não faz sentido ter que reinventar a
printf("Digite um int: "); roda a cada uso e você pode usar as funções sem
nem saber como elas funcionam internamente.
scanf("%d", &a);
char r = c + a;
printf("Char resultante: %c\n", r);
}
6
Função
Unidade de código baseada no conceito de função da matemática, em que uma função
possui zero ou mais variáveis de entrada e sempre retorna um valor como resultado.
Na programação, as funções pertencem à categoria dos subprogramas, que são unidades
de código independentes que resolvem um problema específico.

Subprograma

Função Procedimento Corrotina

Na linguagem C, todos os subprogramas são funções. Portanto, não há procedimentos nem

corrotinas em C.
7
Função
A sintaxe de criação de uma função é:

tipoDeRetorno nomeDaFunção ( parâmetros ) { corpoDaFunção }

• Tipo de retorno: indica qual o tipo do valor do resultado da função;

• Nome da função: nome que identifica a função;
• Parâmetros: variáveis de entrada da função. Uma função pode ter zero ou mais
parâmetros;
• Corpo da função: instruções que compõem o código da função;
• O tipo de retorno, o nome e os parâmetros formam o cabeçalho da função.

8
Função
Vamos analisar a função main.
Parâmetros: a função main não tem
Nome da função parâmetros. Também é correto dizer que
ela não possui entradas.

void main( ) {
int a;
Tipo de retorno: char c;
void significa que
a função tem printf("Digite um char: "); Corpo da função:
retorno vazio. scanf("%c", &c); instruções entre
as chaves.
printf("Digite um int: ");
scanf("%d", &a);
char r = c + a;
printf("Char resultante: %c\n", r);
} 9
Função
O programa a seguir cria a função fatorial e a invoca dentro da função main.
A função main precisa vir depois da função fatorial porque main usa fatorial, assim como
para usar uma variável é preciso declará-la antes.
Essa função possui um parâmetro do
#include<stdio.h> tipo inteiro. O parâmetro recebe o
valor passado na chamada da função
Essa função é do tipo int
porque o valor indicado no int fatorial( int n ) {
comando return é do tipo int.
int f = 1;
for (int i = n; i > 1; i--) {
f = f * i;
}
O comando return encerra
execução da função, retornando return f;
o valor indicado à direita. }
10
Função
void main() {
int x, resp;
printf("Digite um inteiro >= 0: ");
scanf("%d", &x);
Aqui a função fatorial é chamada
recebendo como entrada o valor de x.

resp = fatorial( x );

printf("Fatorial de %d: %d\n", x, resp);

}

11
Parâmetros das Funções
São variáveis que armazenam os valores de entrada de uma função.
Uma função pode ter qualquer quantidade de parâmetros, inclusive nenhum.

float soma(float a, float b) {

return a + b;
}

Os parâmetros são separados

float potencia(float base, int exp) { por vírgula. Note que mesmo
float pot = 1; quando eles são do mesmo
tipo, é preciso declará-los
for ( ; exp > 0; exp--)
separadamente.
pot *= base;
return pot;
}

12
Parâmetros das Funções
Um função que não possui parâmetros não recebe nenhum valor quando é chamada.
Funções sem entrada são declaradas com os parênteses vazios ou contendo a palavra void.

#include <stdio.h>

void imprimeLinhaTracejada(void) {
for (int i = 0; i < 80; i++)
printf("-"); Repare que o uso da palavra
void na declaração de uma
} função sem parâmetros é
opcional.
void main() {
imprimeLinhaTracejada();
}

13
Comando return
Encerra a execução da função e retorna o valor indicado a sua direita para o local onde a
função foi chamada.
• Seu uso é obrigatório em funções cujo tipo não é void;
• Seu uso é opcional em funções do tipo void. Caso seja usado, não deve haver nenhum valor à
sua direita. Por exemplo, a função main pode conter o comando return conforme mostrado
abaixo.

void main() {
printf("\nHello World");
return;
}

Sem o comando return, uma função do tipo void encerra quando a execução atinge a chave
de fechamento do corpo da função. 14
Comando return
O tipo do retorno da função é totalmente independente dos parâmetros de entrada. Por
exemplo, uma função que recebe um inteiro como parâmetro não necessariamente tem
que retornar um inteiro também.

#include<stdio.h>

void imprimeLinhaTracejada(int tam) {

for (int i = 0; i < tam; i++)
printf("-");
}

void main() {
imprimeLinhaTracejada(20);
}
15
Comando return
O comando return pode aparecer mais de uma vez em uma função, porém somente o
primeiro a ser atingido é executado e a função se encerra.

#include<stdio.h> void main() {

int x, resp;
int primo( int n ) { printf("Digite um int > 1: ");
for (int d = 2; d <= n/2; d++) scanf("%d", &x);
if (n % d == 0) printf("%d eh primo? %s.\n", x,
return 0; //n não é primo primo(x) ? "Sim" : "Nao");
return 1; //n é primo }
}

Nesse programa, se o usuário digitar, por exemplo, 49 (não primo), o comando if será
verdadeiro quando d = 7, fazendo com que a sentença return 0 seja executada,
encerrando instantaneamente o laço for e a função. Mas se o usuário digitar, por exemplo,
17 (primo), o comando if nunca será verdadeiro, o laço for encerrará quando d = 9 e a
função encerrará na sentença return 1. 16
Como Funciona uma Função
O programa começa pela função main. Logo após o usuário digitar, por exemplo, 5, a
memória RAM estará como no quadro.
#include<stdio.h>
Memória RAM
int fatorial (int y) {
int fat = 1; endereço nome valor
while (y > 1) { fat *= y--; } 0x01 n 5
return fat; 0x02 f
}
0x03
void main() {
int n; 0x04
printf("Digite um inteiro: ");
scanf("%d", &n);
int f = fatorial(n);
printf("Fatorial de %d: %d\n", n, f);
}
17
Como Funciona uma Função
Quando o programa atinge a chamada da função fatorial, ele se desloca para o código dela
e as variáveis da função fatorial são criadas.
#include<stdio.h>
Memória RAM
int fatorial (int y) {
int fat = 1; endereço nome valor
while (y > 1) { fat *= y--; } 0x01 n 5
return fat; 0x02 f
}
0x03 y
void main() {
int n; 0x04 fat
printf("Digite um inteiro: ");
scanf("%d", &n);
int f = fatorial(n);
printf("Fatorial de %d: %d\n", n, f);
}
18
Como Funciona uma Função
No momento do deslocamento de main para fatorial, o valor de n é copiado para x. Esse
processo é chamado de passagem por valor.
#include<stdio.h>
Memória RAM
int fatorial (int y) {
int fat = 1; endereço nome valor
while (y > 1) { fat *= y--; } 0x01 n 5
return fat; 0x02 f
}
0x03 y 5
void main() {
int n; 0x04 fat
printf("Digite um inteiro: ");
scanf("%d", &n); Note que y apenas recebeu
uma cópia do valor de n,
int f = fatorial(n);
mas elas são variáveis
printf("Fatorial de %d: %d\n", n, f); independentes.
}
19
Como Funciona uma Função
Quando o comando return é atingido, o programa se desloca novamente para a função
retornando o valor da variável fat.
#include<stdio.h>
Memória RAM
int fatorial (int y) {
int fat = 1; endereço nome valor
while (y > 1) { fat *= y--; } 0x01 n 5
return fat; 0x02 f
}
0x03 y 1
void main() {
int n; 0x04 fat 120
printf("Digite um inteiro: ");
scanf("%d", &n); Como y e n são variáveis
int f = fatorial(n); diferentes, alterações em
printf("Fatorial de %d: %d\n", n, f); uma não afetam a outra.
}
20
Como Funciona uma Função
O programa continua a execução da função main a partir do ponto onde havia parado. A
variável f recebe o retorno da função fatorial.
#include<stdio.h>
Memória RAM
int fatorial (int y) {
int fat = 1; endereço nome valor
while (y > 1) { fat *= y--; } 0x01 n 5
return fat; 0x02 f 120
}
0x03
void main() {
int n; 0x04
printf("Digite um inteiro: ");
scanf("%d", &n); Quando a função fatorial é
encerrada, todas as variáveis
int f = fatorial(n);
criadas dentro dela são
printf("Fatorial de %d: %d\n", n, f); apagadas da memória.
}
21
Assinatura de Função
Já foi citado que uma função possui cabeçalho e corpo.
Por exemplo, na função abaixo, o cabeçalho é mostrado em azul e o corpo em vermelho.

int fatorial (int y) {

int fat = 1;
while (y > 1) { fat *= y--; }
return fat;
}

22
Assinatura de Função
Também já foi dito que para usar uma função, é necessário que a mesma tenho sido declarada
antes.
O compilador acusaria um erro no código abaixo, informando que a função main não reconhece a
função soma.

#include<stdio.h>
ERRO DE COMPILAÇÃO:
void main() { A função soma não foi
int a, b; declarada antes do seu
printf("Digite dois inteiros: "); uso.
scanf("%d %d", &a, &b);
printf( "%d + %d = %d\n", a, b, soma(a,b) );
}
int soma (int x, int y) {
return x + y;
}
23
Assinatura de Função
Mas o que acontece com o código abaixo.

#include<stdio.h>
void imprimePar (int x) {
if ( x % 2 != 0 ) imprimeImpar(x);
E agora?
else printf("\n%d eh par.", x);
Qual função deve vir
} primeiro no código?
void imprimeImpar (int x) {
if ( x % 2 == 0 ) imprimePar(x);
else printf("\n%d eh impar.", x);
}
void main() {
imprimePar(3);
imprimeImpar(4);
}
24
Assinatura de Função
#include<stdio.h>

void main(void); Para esses casos, é necessário declarar a

void imprimeImpar (int); assinatura das funções antes de implementá-las.
void imprimePar (int);
• A assinatura de uma função consiste apenas do
void main() { cabeçalho finalizado com ponto-e-vírgula (;);
imprimeImpar(4);
imprimePar(3);
• Em C, os parâmetros das funções nas assinaturas
}
possuem apenas a indicação do tipo;
void imprimeImpar (int x) { • Usando assinaturas, as funções podem estar
if ( x % 2 == 0 ) imprimePar(x); implementadas em qualquer ordem;
else printf("\n %d eh impar.\n", x);
} • O uso de assinaturas é sempre recomendado, pois
void imprimePar (int x) { servem como um sumário das funções que
if ( x % 2 != 0 ) imprimeImpar(x); existem no arquivo.
else printf("\n %d eh par.\n", x);
}
25
Array como Parâmetro de Função
Na declaração da função, é preciso incluir os colchetes junto ao nome do parâmetro, mas
sem indicar o tamanho.
Na chamada, deve-se indicar somente o nome do array, portanto, o que o parâmetro
recebe é o endereço inicial do array.
#include<stdio.h>
int tamanho ( char str[] ) {
int tam = 0;
while( str[tam] != '\0' ) tam++;
return tam;
}
void main() {
char nm[50] = "MATHEUS VIANA";
printf("\n%s possui %d caracteres.\n", nm, tamanho( nm ) );
}
26
Array como Parâmetro de Função
Para arrays que não sejam do tipo char, pode ser necessário adicionar mais um parâmetro
para informar o tamanho do array.

#include<stdio.h>
Sem o parâmetro que indica o
int somaElementos ( int v[], int tam ) { tamanho do array, não há como
int soma = 0; a função saber quando o while
while (--tam >= 0) soma += v[tam]; deve parar.

return soma;
}
void main() {
int numeros[5] = {1,2,3,4,5};
printf("\nSoma: %s\n", somaElementos( numeros, 5 ) );
}

27
Array como Parâmetro de Função
Quando o tipo de um parâmetro é um array com duas ou mais dimensões, é preciso incluir
o tamanho de cada dimensão a partir da segunda.
#include<stdio.h>
int somaElementos ( int v[][3] ) {
int soma = 0;
for (int i = 0; i < 3; i++);
for (int j = 0; j < 3; j++)
soma += v[i][j];
return soma;
}
void main() {
int ns[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
printf("\nSoma: %s\n", somaElementos( ns ) );
}
28
Array como Retorno de Função
Em C, há dois problemas quando se deseja criar uma função que retorna um array:
1. Uma função só pode retornar um único valor, então, não é possível retornar um array. A saída
seria retornar apenas o endereço inicial do array, mas...
2. A linguagem não permite o retorno do endereço de uma variável local para fora da função.
Então é preciso que o array seja uma variável estática (static):
a) uma variável declarada como estática continua existindo mesmo quando a função onde ela
foi declarada é encerrada;
b) Contudo, seu tamanho deve ser definido em tempo de compilação.

Na declaração da função e na variável que irá receber o array na chamada, é preciso incluir
um asterisco (*) no lugar dos colchetes.
No comando return, deve-se indicar somente o nome do array.

29
Array como Retorno de Função
#include<stdio.h>

int* obterArray ( ) {
static int v[5];
for (int i = 0; i < 5; i++)
v[i] = i;
return v;
}
void main() {
int *ns = obterArray();
for (int i = 0; i < 5; i++)
printf( " %d ", ns[i] );
}

30
Tipos Definidos pelo Programador
Diferentemente do que ocorre com os arrays, não há restrição alguma quanto ao uso de
registros como parâmetros ou retorno de funções.

#include<stdio.h>

typedef struct { void main() {

float x, y; ponto P1 = { 1, 3 };
} ponto; ponto P2 = { 5, 4 };
ponto P3 =
ponto somaPontos (ponto A, ponto B) { somaPontos( P1, P2 );
ponto S; printf( "Soma: (%.1f,%.1f)", P3.x, P3.y );
S.x = A.x + B.x;
S.y = A.y + B.y; }
return S;
}

31
Variáveis Globais
Apesar de não ser muito recomendado, é possível declarar variáveis fora das funções.

Uma variável declarada fora das funções é chamada de variável global, pois pode ser
acessada em qualquer função do programa a partir do ponto onde foi declarada.

Variáveis globais são sempre estáticas, ou seja, são colocadas na memória no início da
execução do programa e persistem até que ele seja fechado.

32
Variáveis Globais
#include<stdio.h>
const int TAM = 5;
int v[5];

void obterArray ( ) {
for (int i = 0; i < TAM; i++)
v[i] = i;
}
void main() {
obterArray();
for (int i = 0; i < TAM; i++)
printf( " %d ", v[i] );
}
33
Estrutura de um Programa
Um arquivo com o código-fonte de um programa, contendo as diferentes estruturas vistas,
deve ser organizado com base na seguinte sequência:

[DIRETIVAS]

[TIPOS DEFINIDOS PELO PROGRAMADOR]

[VARIÁVEIS GLOBAIS]

[ASSINATURAS DE FUNCOES]

[FUNÇÕES]

34