Funções em C

Prévia do material em texto

LAPRO	I
Prof.	Dr.	Rafael	Garibotti
Pontifícia	Universidade	Católica	do	Rio	Grande	do	Sul	
Faculdade	de	Informática	- FACIN
v Baseado no	material	cedido pelos Profs.	Dr.	Marco	Mangan e	Dr.	Matheus	Trevisan
FUNÇÕES
AULA	SOBRE:
FORMA	GERAL	DE	UMA	FUNÇÃO
1
Ø Sintaxe:
<tipo_retorno> <nomef> ([<lista_parâmetros>]) {
<declarações> // variáveis locais
<comandos>
return [<expressão>];
}
ü tipo_retorno:	Tipo	de	retorno	da	função,	pode	ser	int,	float,	double,	char e	
outros.	Mas	o	tipo	especial	void não	retorna	nenhum	valor;
ü nomef:	Nome	da	função.
FORMA	GERAL	DE	UMA	FUNÇÃO
2
ü lista_parâmetros:
• Também	chamada	de	lista	de	argumentos.	É	opcional.
• O	nome	do	argumento	sempre	vem	precedido	de	seu	tipo.
• Os	diversos	argumentos	são	separados	por	vírgula.
tipo1	arg1,	tipo2	arg2,	...,	tipon argn
ü return:
• Indica	o	término	da	função.	Retorna	o	controle	para	o	local	onde	a	função	foi	
ativada	(chamada).
• O	tipo	de	dado	da	<expressão>	deve	ser	do	mesmo	tipo	que	o	definido	no	
<tipo_retorno>	da	função.
• Se	o	<tipo_retorno>	da	função	for	void (não	retorna	nada)	então	o	valor	da	
<expressão>	deve	ser	omitido.
• O	comando	return tem	capacidade	de	retornar	apenas	UM	valor.
FORMA	GERAL	DE	UMA	FUNÇÃO
3
Ø Exemplos	de	retornos	de	funções:
ü Corretos:
void func1( ) {
<comandos>
}
int func2( ) {
<comandos>
return 1;
}
void func3( ) {
<comandos>
return;
}
ü Incorretos:
void func1( ) {
<comandos>
return 0;
}
int func2( ) {
<comandos>
return;
}
float func3( ) {
<comandos>
}
FORMA	GERAL	DE	UMA	FUNÇÃO
4
Ø Exemplo:
#include <stdio.h>
void func_teste(){
printf("Eu sou a funcao teste!!\n\n");
}
int main(){
printf("Sou a funcao principal e vou chamar a 
func_teste\n");
func_teste();
printf("Agora sou eu, a funcao principal de novo!\n\n");
return 0;
}
ESCOPO	DE	VARIÁVEIS
ESCOPO	DE	VARIÁVEIS
5
Ø Representa	a	área	do	programa	em	que	a	variável	pode	ser	utilizada.	As	
variáveis	podem	ser	classificadas	em:
Ø Locais:
ü São	as	variáveis	declaradas	dentro	do	corpo	da	função.	São	visíveis	
somente	nesta	função.	O	programa	principal	(main)	e	as	demais	funções	
não	podem	utilizar	esta	variável.
ü Tempo	de	vida:	duração	da	função.
Ø Globais:
ü São	as	variáveis	declaradas	fora	das	funções.	Estas	variáveis	são	visíveis	por	
todas	as	funções	do	programa.
ü Tempo	de	vida:	enquanto	o	programa	estiver	sendo	executado.	
ESCOPO	DE	VARIÁVEIS
6
Ø Exemplo:
#include <stdio.h>
int y=20; //variavel global
void funcao_teste(){
int x=80, z=30; //variaveis locais à funcao_teste
printf("Somos as variaveis x e z da funcao_teste: %d, %d\n", x, z);
y = 55;
printf("Sou a variavel y, global, na funcao_teste! %d\n",y);
}
int main(){
int x=10, z=15; //variaveis locais à funcao principal
printf("Somos as variaveis x e z da funcao principal: %d, %d\n", x, z);
printf("Sou a variavel y, global, na funcao principal antes de chamar a funcao teste! 
%d\n",y);
funcao_teste();
printf("Somos, de novo, as variaveis x e z da funcao principal: %d, %d\n", x, z);
printf("Sou a variavel y, global, na funcao principal depois de chamar a funcao teste! 
%d\n",y);
return 0;
}
PARÂMETROS
7
Ø As	funções	podem	se	comunicar	de	duas	formas:
ü através	das	variáveis	globais:	não	recomendável,	evitar;
ü através	dos	parâmetros existentes	nas	funções.
Ø Os	parâmetros	são	categorizados	em:
ü Parâmetros	formais:
• São	os	parâmetros	utilizados	na	definição	da	função.	Devem	ser	
variáveis	e	são	tratadas	como	variáveis	locais.
ü Parâmetros	reais:
• São	os	parâmetros	utilizados	na	chamada	da	função.	Podem	ser	tanto	
variáveis	quanto	valores.	Os	parâmetros	reais	são	utilizados	para	
inicializar	os	parâmetros	formais.
PARÂMETROS
8
Ø Os	parâmetros	formais	e	reais	devem	se	corresponder	em:
ü Número
Ø Exemplo:
#include <stdio.h>
float media(float x, float y, float z){
return (x+y+z)/3;
}
int main(){
float n1,n2,med;
printf ("Entre com duas notas:");
scanf ("%f %f", &n1, &n2);
med = media(n1, n2, 8.5);
printf ("Media = %.2f\n", med);
return 0;
}
//	Parâmetros Formais
//	Parâmetros Reais
ü Tipo	de	dado ü Ordem
CHAMADAS	DE	UMA	FUNÇÃO
9
Ø As	funções	podem	ser	classificadas	de	dois	tipos:
1. Procedimento:	não	retornam	nada	(void).
Ø Exemplo:
#include <stdio.h>
void funcao_teste(int a, int b){
printf("A soma dos parametros eh %d\n",a+b);
}
int main(){
int x=10, z=15; 
printf("Somos as variaveis x e z da funcao principal: %d, %d\n", x, z);
funcao_teste(x, z); //Sempre um comando isolado no local da chamada.
printf("Sou a funcao principal de novo!\n\n");
return 0;
}
CHAMADAS	DE	UMA	FUNÇÃO
10
2. Função:	retorna um	valor	através	do	comando	return.
Ø Exemplo:
#include <stdio.h>
int funcao_soma (int a, int b){
int soma;
soma = a + b;
return soma;
}
int main( ){
int x=10, y=15, resultado; 
printf("Somos as variaveis x e y da funcao principal: %d, %d\n", x, y);
resultado = funcao_soma(x, y);
printf("Sou a funcao principal de novo e o resultado da soma eh %d!\n\n", 
resultado);
return 0;
}
ü Atribui	o	resultado	a	uma	variável
res = funcao_soma(x, y);
ü Atribui	o	resultado	a	uma	condição
if ( funcao_soma(x,y) > 10 )
ü Atribui	o	resultado	a	uma	saída	de	dados
printf(“soma = %d“, funcao_soma(x,y));
PASSAGEM	DE	PARÂMETROS
11
Ø Existem	dois	mecanismos	de	passagem	de	parâmetros:
1. Passagem	por	valor	(by value):	passa	uma	cópia	dos	valores	da	chamada	para	os	argumentos.	
As	alterações	nos	argumentos	não	tem	reflexo	fora	da	função.	Os	argumentos	são	de	entrada:	
só	recebem	valores.
Ø Exemplo:
#include <stdio.h>
int produto(int x, int y) {
return x*y;
}
int main( ) {
int v1, v2;
printf ("Entre com dois valores:");
scanf ("%d %d", &v1, &v2);
printf ("Produto = %d\n", produto(v1,v2)); //	Passa	os	valores	para	a	função produto.
return 0;
}
PASSAGEM	DE	PARÂMETROS
12
2. Passagem	por	referência (by reference):	passa	o	endereço	de	memória	da	variável	da	chamada	
para	o	argumento.	As	alterações	realizadas	nos	argumentos	afetarão	as	variáveis	na	chamada.	
Os	argumentos	são	de	entrada	e	saída:	recebem	e	devolvem	valores.
Ø Exemplo:
#include <stdio.h>
void somaprod(int x, int y, int *s, int *p){
*s = x+y;
*p = x*y;
}
int main( ) {
int v1, v2, s, p;
printf ("Entre com dois valores:");
scanf ("%d %d", &v1, &v2);
somaprod(v1, v2, &s, &p); 
printf ("Soma = %d\nProduto = %d\n", s, p);
return 0;
}
//	*	na	função
//	&	na	chamada
PASSAGEM	DE	PARÂMETROS
13
QUAL	A	DIFERENÇA???
ØNa	passagem	por	VALOR,	as	variáveis	que	foram	como	parâmetro	de	
quem	ESTÁ	CHAMANDO	a	função	PERMANECEM	COM	OS	MESMOS	
VALORES!
ØNa	passagem	por	REFERÊNCIA,	as	variáveis	que	foram	como	parâmetro	de	
quem	ESTÁ	CHAMANDO	a	função	PODEM	SER	MUDADAS	PELA	FUNÇÃO	
CHAMADA!
PASSAGEM	DE	PARÂMETROS
14
Ø Exemplo	(diferença	entre	passagem	por	valor	e	por	referência):
#include <stdio.h>
void pass_valor(int a, int b){
a = 10; b = 15;
printf ("Imprimindo na funcao pass_valor a=%d e b=%d\n",a,b);
}
void pass_ref(int *a, int *b){
*a = 10; *b = 15;
printf ("Imprimindo na funcao pass_ref a=%d e b=%d\n",*a,*b);
}
int main( ){
int x=100, z=200;
printf("Somos x = %d e z = %d da funcao principal ANTES de chamar pass_valor.\n", x, z);
pass_valor(x, z);
printf("Somos x = %d e z = %d da funcao principal DEPOIS de chamar pass_valor.\n\n", x, z);
printf("Somos x = %d e z = %d da funcao principal ANTES de chamar pass_ref.\n", x, z);
pass_ref(&x, &z);
printf("Somos x = %d e z = %d da funcao principal DEPOIS de chamar pass_ref.\n\n", x, z);
return 0;
}
ESCOPO	E	LOCALIZAÇÃO	DE	FUNÇÕES
LOCALIZAÇÃO	DAS	FUNÇÕES
15
Ø Regra:
ü Toda	a	função	deve	ser	declarada antes	de	ser	usada.
ü Quando	a	função	é	definida,	automaticamente	está	declarada.Ø Exemplo:
#include <stdio.h>
int soma(int a, int b){
return a + b;
}
int main( ){
int x, y, resultado;
printf ("Informe dois numeros inteiros: ");
scanf ("%d %d", &x, &y);
resultado = soma(x, y);
printf ("%d + %d = %d\n", x, y, resultado);
return 0;
}
//	Definição da	função
//	Chamada da	função
LOCALIZAÇÃO	DAS	FUNÇÕES
16
Ø Protótipo da	função:
ü Permite	que	a	função	seja	utilizada	antes	de	sua	definição.
Ø Exemplo:
#include <stdio.h>
int soma(int a, int b);
int main( ){
int x, y, resultado;
printf ("Informe dois numeros inteiros: ");
scanf ("%d %d", &x, &y);
resultado = soma(x, y);
printf ("%d + %d = %d\n", x, y, resultado);
return 0;
}
int soma(int a, int b){
return a + b;
}
//	Definição da	função
//	Chamada da	função
//	Protótipo da	função
RECURSIVIDADE
RECURSIVIDADE
17
Ø Uma função pode chamar a	si	própria,	o	que pode facilitar a	resolução de	alguns problemas
usando programação.
ü Várias funções matemáticas podem ser	facilmente implementadas usando recursividade.
Ø Exemplo (escreve na	tela os	valores a	partir de	10	até 20):
#include <stdio.h>
void escreva(int inicio, int fim){
printf("%d ", inicio);
if (inicio < fim)
escreva(inicio + 1, fim);
}
int main(){
escreva(10, 20);
printf("\n");
return 0;
}
ATIVIDADE
LABORATÓRIO
18
Ø As	atividades	do	laboratório	da	aula	de	hoje	estão no	Moodle.