Linguagem C - Funções

Prévia do material em texto

Informática Aplicada - Linguagem C 
Funções 
Profª Náthalee Cavalcanti de Almeida 
Email: nathalee.almeida@ufersa.edu.br 
24/01/2014 
• Cabeçalho e corpo de uma função 
• Parâmetros 
• Passagem de parâmetros de tipos básicos 
• Valor de retorno (return) 
• O “tipo” void 
• Protótipos de funções 
• Variáveis locais 
 
Agenda 
Características de uma Função 
• Cada função tem que ter um nome único, o qual serve para a sua 
invocação em algum lugar no programa a que pertence. 
 
• Um função pode ser invocada a partir de outras funções. 
 
• Uma função ( como o nome indica) deve realizar UMA ÚNICA 
TAREFA bem definida. 
 
• O código de uma função deve ser o mais independente possível do 
resto do programa, e deve ser tão genérico quanto possível, para poder 
ser reutilizado em outros projetos. 
 
• Uma função pode retornar, para a entidade que a invocou, um valor 
como resultado do seu trabalho. 
 
 
 
 
 
 
 
 
 
Nome de uma Função 
 
• Obedece às regras apresentadas para variáveis; 
 
• O nome de uma função deve ser único ( não pode ser igual ao nome 
de outra função ou de uma variável); 
 
• O nome de uma função deve especificar aquilo que a função na 
realidade faz, e deve ser de fácil leitura e interpretação (Ex: putchar 
vs. p23_k45_char). 
 
 
 
 
 
 
Como Funciona uma Função 
 
• O código de uma função só é executado quando esta é 
invocada em alguma parte do programa a que está de algum 
modo ligada. 
 
• Sempre que uma função é invocada, o programa que a 
invoca é “suspenso” temporariamente. Em seguida, serão 
executadas as instruções presentes no corpo da função. Uma 
vez terminada a função, o controle de execução do programa 
volta ao local em que esta foi invocada. 
 
 
 
 
Como Funciona uma Função 
 
• O programa que invoca uma função pode enviar 
Argumentos, que são recebidos pela função. Estes são 
recebidos e armazenados em variáveis locais, que são 
automaticamente iniciadas com os valores enviados. A essas 
variáveis dá-se o nome de Parâmetros. 
• Depois de terminar seu funcionamento, uma função pode 
devolver um valor para o programa que o invocou. 
 
 
 
Funções 
 
Problema: Escreva um programa que, recorrendo a três funções 
distintas, escreva na tela a seguinte saída: 
 
*** 
***** 
******* 
***** 
*** 
 
Funções 
 #include <stdio.h> linha3x ( ) 
{ 
 int i; 
 for (1=1; i < = 3; i++){ 
 putchar („*‟);} 
 putchar („\n‟); 
} 
 
 linha5x ( ) 
{ 
 int i; 
 for (1=1; i < = 5; i++){ 
 putchar („*‟);} 
 putchar („\n‟); 
} 
 
 
 
Funções 
 linha7x ( ) { 
 int i; 
 for (1=1; i < = 7; i++){ 
 putchar („*‟);} 
 putchar („\n‟); 
} 
main ( ) 
{ 
 linha3x ( ); 
 linha5x ( ); 
 linha7x ( ); 
 linha5x ( ); 
 linha3x ( ); 
} 
 
 
Funções 
 
• linha3x ( ): função responsável por escrever três 
asteriscos na tela 
 
• linha5x ( ): função responsável por escrever cinco 
asteriscos na tela 
 
• linha7x ( ): função responsável por escrever sete 
asteriscos na tela 
 
• main: função que invoca as funções. 
 
Funções 
 
• O ideal seria escrever uma única função linha, 
responsável pela escrita de uma linha na tela, com 
um número de asteriscos específico em cada 
chamada. 
• se quisermos 3 asteriscos invocamos a função linha 
(3). 
• se quisermos 5 asteriscos invocamos a função linha 
(5). 
• se quisermos 7 asteriscos invocamos a função linha 
(7). 
 
Funções 
 
• A função é sempre a mesma (função linha), o que 
muda é o número de caracteres para serem 
colocados na tela. 
• No programa anterior o nosso main passaria a ser: 
 
• main (){ 
• linha(3); 
• linha(5); 
• linha(7); 
• linha(5); 
• linha(3); 
} 
 
Funções 
 
• Como seria então escrita a função linha? 
 
• A função linha recebe dentro de parênteses um 
valor do tipo inteiro, o qual terá que ser colocado 
numa variável. 
 
• Depois de armazenado o valor, o laço da função 
linha terá que executar o número de vezes que está 
armazenado nessa variável. 
 
Funções 
 
• Qual o nome da função a ser escrita? 
 linha ( ) 
 
• Quantos parâmetros vai receber? 
 1 
 
• Qual o tipo de parâmetro? 
 inteiro 
 
• Escolha o nome para a variável que vai 
armazenar esse parâmetro 
num 
 
 
 
 
 
 
Funções 
 
• O cabeçalho da função será assim 
 linha (int num) 
 
• E o corpo da função? 
 
Bastará alterar a condição de controle do laço 
para 
 for (i=1; i<=num ; i++) 
 
 
 
 
 
 
Funções 
 
O programa anterior poderia ser escrito da seguinte 
forma: 
 
 
 
 
 
 
#include <stdio.h> 
linha (int num) 
{ 
 int i; 
 for (1=1; i < = num; i++){ 
 putchar („*‟);} 
 putchar („\n‟); 
} 
main ( ) 
{ 
 linha(3); 
 linha (5); 
 linha (7); 
 linha(5 ); 
 linha ( 3); } 
 
Funções - Parâmetros 
 
• A comunicação com uma função se faz através dos 
argumentos que lhe são enviados e dos parâmetros 
presentes na função que os recebe. 
 
• O número de parâmetros de uma função pode ser 0, 
1, 2, etc., dependendo apenas das necessidades do 
programador. 
 
• Cada função necessita, no entanto, saber qual o tipo 
de cada um dos parâmetros. 
 
 
 
 
 
 
Funções - Parâmetros 
 
• Os parâmetros de uma função são separados por vírgula, e 
é absolutamente necessário que para cada um deles seja 
indicado o seu tipo. 
 
funcao (int x, char y, float k, double xpto) 
 
funcao (int x, int y, int k, int xpto)  Exemplo Correto 
 
funcao (int x, y, k, xpto)  Exemplo Incorreto 
 
Um parâmetro é uma variável local à função a que 
pertence. 
 
 
 
 
 
 
Funções - Parâmetros 
 
• A passagem de argumentos para uma função deve ser 
realizada colocando-os dentro de parênteses, separados 
por vírgulas, imediatamente após o nome da função. 
 
 
• Quando se faz a chamada de uma função, o número e o 
tipo dos argumentos enviados devem coincidentes com os 
parâmetros presentes no cabeçalho da função. 
 
 
 
 
 
 
Funções - Parâmetros 
 • Exemplo: 
main( ){ 
 ... 
 funcao („A‟, 123, 23.456); 
 ... 
} 
 
funcao ( char ch, int n, float x) 
{ 
 ... 
} 
O n° de parâmetros enviados para uma função deve ser igual ao 
n° de parâmetros existente no cabeçalho da função. O tipo dos 
parâmetros deve igualmente corresponder, parâmetro a 
parâmetro. 
 
 
 
 
 
 
Funções - Parâmetros 
 
• Se a função receber mais de um parâmetro, os argumentos 
enviados são associados aos parâmetros da função pela 
ordem em que são escritos. 
 
Problema: 
 
Altere o programa anterior de forma que a função linha 
escreva qualquer caractere, e não apenas o caractere 
asterisco. 
 
 
 
 
 
 
Funções 
#include <stdio.h> 
linha (int num, char ch) 
{ 
 int i; 
 for (i=1 ; i<=num ; i++) 
 putchar (ch); 
 putchar(„\n‟); 
} 
main ( ) 
{ 
 linha (3,‟+‟); 
 linha (5,‟+‟); 
 linha (7,‟-‟); 
 linha (5,‟*‟); 
 linha (3,‟*‟); 
} 
 
 
 
 
 
 
 
Funções 
Saída: 
+++ 
+++++ 
------- 
***** 
*** 
 
 
 
 
 
 
Corpo de uma Função 
• O corpo de uma função é constituído por instruções de C 
de acordo com a sintaxe da linguagem. 
 
• O corpo de uma função tem que seguir imediatamente ao 
cabeçalho dafunção, e é escrito entre chaves. 
 
• O cabeçalho de uma função NUNCA deve ser seguido de 
ponto-e-virgula (;) 
 
 
 
 
 
Corpo de uma Função 
• Sempre que uma função é invocada pelo programa, o 
corpo da função é executado, instrução a instrução, até 
terminar o corpo da função ou até encontrar a instrução 
return, voltando imediatamente ao programa em que foi 
invocada. 
 
• Dentro do corpo de uma função pode-se escrever 
qualquer instrução ou conjuntos de instruções da 
linguagem C. 
• Em C não se pode definir funções dentro de funções. 
 
 
 
 
Corpo de uma Função 
• Qualquer instrução é admissível dentro de uma função 
(ex.: atribuições, if, for, switch, ..., invocar outras funções, 
etc.). 
 
• O número de instruções que pode estar presente dentro de 
uma função não tem qualquer limite, deve, no entanto, ser 
relativamente pequeno e responsável por realizar uma 
única tarefa. 
 
 
 
 
return 
• A instrução return permite terminar a execução de uma 
função e voltar ao programa que a invocou. 
• A execução da instrução return na função main faz com 
que o programa termine. 
Exemplo: 
#include <stdio.h> 
main ( ) 
{ 
 printf(“Hello”); 
 return; 
 printf(“World\n”); 
} 
 
 
 
 
Funções que retornam um valor 
• É possível que uma função seja responsável por realizar 
uma determinada tarefa e que, uma vez terminada essa 
tarefa, devolva UM ÚNICO resultado. 
 
• Esse resultado poderá ser armazenado numa variável ou 
aproveitado por qualquer instrução. 
 
• A devolução de um resultado é feita através da instrução 
return, seguida do valor a ser devolvido. 
 
• Após a instrução return pode ser colocada qualquer 
expressão válida em C. 
 
 
 
Funções que retornam um valor 
• Suponha que quiséssemos calcular a soma de dois 
números inteiros. 
 
• A função responsável por essa tarefa deverá ter a 
capacidade de realizar a soma e de retornar o resultado 
desta. 
 
 n = soma(3,4); 
 printf (“%d\n”, n); 
 
 
Funções que retornam um valor 
• Note que a função soma terá que receber dois inteiros e 
terá que devolver um resultado do tipo inteiro, que 
corresponderá à soma dos dois parâmetros recebidos pela 
função. 
 
 int soma (int x, int y) 
 { 
 int res; 
 res = x+y; 
 return res; 
 } 
 
 Repare que a soma de x com y é colocada numa variável do tipo inteiro 
 que em seguida é devolvida como resultado da função. 
Parâmetros 
Valor a Retornar 
Tipo de Retorno 
Exercícios 
 
 
Escreva um programa que solicite dois números ao usuário e 
apresente na tela o resultado da sua soma e o dobro de cada 
um deles. ( Utilize funções!!) 
Exercícios 
#include <stdio.h> 
/*Devolve a soma de dois inteiros*/ 
int soma (int a, int b) 
{ 
 return a+b; 
} 
 
/*Devolve o dobro de qualquer inteiro*/ 
int dobro (int x) 
{ 
 return 2*x; 
} 
 
Exercícios 
main ( ) 
{ 
 int n, i, total; 
 printf (“Digite dois numeros:”); 
 scanf (“%d%d”, &n, &i); 
 total = soma ( n, i); 
 printf(“%d+%d=%d\n”, n, i, total); 
 printf(“2*%d = %d e 2*%d = %d\n”, n, dobro(n), i, 
 dobro(i)); 
} 
 
Exercícios 
Saída: 
Digite dois numeros: 4 7 
4+7 = 11 
2* 4 = 8 e 2 *7 = 14 
 
 
• Uma vez que a função dobro devolve um inteiro, o seu 
resultado pode ser usado dentro de um printf, sendo 
escrito com o formato de inteiro (%d). 
 
• Um função pode ser invocada dentro de outra função. 
O resultado é o mesmo que se obteria se, em vez da 
chamada à função, aí estivesse o resultado devolvido 
por esta. 
 
 
 
Exercícios 
Qual a saída da seguinte linha? 
 
printf(“%d”, dobro (soma(dobro(2), 3))); 
 
 
 
Exercícios 
Qual a saída da seguinte linha? 
 
printf(“%d”, dobro (soma(dobro(2), 3))); 
 
 
 
dobro(2) 4 
soma(dobro(2), 3) soma (4,3)  7 
dobro (soma(dobro(2), 3)) dobro (soma(4,3))  dobro(7) 
 14 
 
O valor colocado na tela seria 14. 
 
 
Exercícios 
A execução anterior seria semelhante a: 
 
a= dobro (2); 
b = soma(a, 3); 
c= dobro(b); 
printf(“%d”, c); 
 
 
Função 
 
• Um função pode conter várias instruções return. No 
entanto, apenas uma instrução return é executada na 
função. 
• Exemplo: Escreva uma função que calcule qual o maior de 
dois inteiros. 
 
int max(int n1, int n2){ 
if (n1>n2) 
 return n1; 
else 
 return n2;} 
 
• Por que a função retorna um inteiro??? 
 
O “tipo” void 
• Em C existe uma palavra reservada – void – que permite 
indicar que uma função não devolve qualquer tipo. 
• Dessa forma, a função linha anteriormente apresentada 
deveria ter sido escrita da seguinte forma: 
#include <stdio.h> 
 void linha (int num, char ch){ 
 int i; 
 for (i=1 ; i<=num ; i++){ 
 putchar (ch);} 
 putchar(„\n‟);} 
main ( ){ 
 linha (3,‟+‟); 
 linha (5,‟+‟); 
 linha (7,‟-‟); 
 linha (5,‟*‟); 
 linha (3,‟*‟);} 
O “tipo” void 
• É comum, encontrar a palavra reservada void para indicar 
que uma função não recebe qualquer parâmetro. 
 
• Os dois trechos são equivalentes 
void linha () 
{ int i; 
 for (i=1; i<=20; i++) 
 putchar(„*‟); 
 putchar („\n‟); 
} 
 
void linha (void) 
{ int i; 
 for (i=1; i<=20; i++) 
 putchar(„*‟); 
 putchar („\n‟); 
} 
 
• Uma função que “retorna void”, normalmente é chamada de 
Procedimento. 
Onde Colocar as Funções 
#include <stdio.h> 
main ( ) 
{ 
 linha ( ); 
 printf(“Hello World\n”); 
 linha( ); 
} 
 
void linha ( ) 
{ 
 int i; 
 for (i=1; i<=20; i++) 
 putchar(„*‟); 
 putchar(„\n‟); 
} 
Onde Colocar as Funções 
#include <stdio.h> 
main ( ) 
{ 
 linha ( ); 
 printf(“Hello World\n”); 
 linha( ); 
} 
 
void linha ( ) 
{ 
 int i; 
 for (i=1; i<=20; i++) 
 putchar(„*‟); 
 putchar(„\n‟); 
} 
Erro de Compilação!!! 
“function linha: redefinition” 
 
Onde Colocar as Funções 
• Como na altura em que a função main é compilada o 
compilador ainda não a conhece, este cria um protótipo 
(cabeçalho) para a função linha semelhante a 
 
 int linha ( ); 
 
• Quando encontra a função linha (com o cabeçalho void 
linha ( ) ), o compilador pensa que são duas funções 
distintas (pois devolvem tipos diferentes) mas com 
mesmo nome. 
• Como em C não podem existir duas funções com o 
mesmo nome, o compilador apresenta o correspondente 
erro e termina o processo de compilação. 
• Note que se a função linha devolvesse um inteiro não 
haveria qualquer problema. 
Onde Colocar as Funções 
• Como resolver esse problema? 
 
• Indicar ao compilador qual o cabeçalho da função, 
fazendo a declaração da função da mesma forma 
que se declaram as variáveis. 
 
• A declaração de uma função consiste na escrita do 
seu cabeçalho seguida de um ponto-e-vírgula (;), e 
deve ser realizada antes da utilização da função 
que se quer declarar. 
 
• Tradicionalmente, a declaração é realizada 
imediatamente após os #includes 
Onde Colocar as Funções 
#include <stdio.h> 
void linha ( ); /* Declaração da Função linha */ 
main ( ) 
{ 
 linha ( ); 
 printf(“Hello World\n”); 
 linha( ); 
} 
 
void linha ( ) 
{ 
 int i; 
 for (i=1; i<=20; i++) 
 putchar(„*‟); 
 putchar(„\n‟); 
} 
Protótipos de funções 
• Corresponde ao seu cabeçalho seguido de um ponto-e-
vírgula (;). 
 
• Este identifica toda a estrutura da função (nome, 
parâmetros e tipo de retorno). 
 
• O protótipo de umadeterminada função deve ser 
colocado apenas antes de sua invocação. No entanto, é 
uma boa prática de programação colocar os cabeçalhos de 
todas as funções definidas pelo programador 
imediatamente antes do código da primeira função. 
 
Protótipos de funções 
#include <...> 
void f1 (int n, char ch); /* Protótipos das funções */ 
int max (int n1, int n2); 
main ( ) 
{ 
 ..... 
} 
void f1 (int n, char ch) 
{ 
 ...... 
} 
int max(int n1, int n2) 
{ 
 ..... 
} 
 
Variáveis Locais 
• Vimos que variáveis podem ser declaradas dentro do 
corpo de uma função. 
• Essa variáveis são visíveis (conhecidas) apenas dentro da 
própria função. 
• A declaração de variáveis dentro de uma função deve ser 
realizada antes de qualquer instrução. 
 
função (..................) 
{ 
 declaração de variáveis 
 instruções 
} 
 
Considerações Finais 
• Como a linguagem C não possui um tipo de dados 
específico para representar os valores lógicos Verdade e 
Falso, é necessário que funções que tenham que devolver 
como resultado um valor lógico sejam declaradas como 
devolvendo um valor do tipo int. 
 
Problema: Escreva a função isequal, que verifica se dois 
inteiros são ou não iguais e devolve o correspondente 
resultado. 
 
int isequal (int x, int y) 
{ 
 if (x == y) 
 return 1; 
 else 
 return 0;}