Parte1SlidesUFuncoes

(1)

Funções

(2)

Introdução

• Para a construção de programas estruturados

– Preferível

dividir as tarefas

em tarefas menores

– Utilizar

resultados parciais

para compor o resultado

final desejado

• Criação de funções

é o mecanismo adequado

para codificar tarefas específicas

• Um programa estruturado deve ser composto

por

diversas funções pequenas

– Facilita a

codificação

(3)

Introdução

• Um procedimento repetido pode ser

transformado em uma função

– Será

chamada diversas vezes

• Um programa deve ser pensado em

termos de funções

– Que devem

esconder

do corpo principal

(4)

Forma geral de uma função

tipo_retorno nome_funcao (lista de parametros)

{

corpo da função

}

Onde:

– tipo_retorno

é o tipo de valor retornado pela função

– nome_funcao

é o nome da função

– lista de parametros

é a lista das variáveis que

recebem os argumentos quando a função é

chamada. Deve incluir o tipo e nome de cada

variável. Sua sintaxe é: (

tipo variável1, tipo variável2,

..., tipo variável n

)

– corpo da função

é onde estão as instruções da

(5)

Forma geral de uma função

tipo nome (tipo nome1, tipo nome2, ..., tipo nomeN ) {

declaração das variáveis corpo da função

}

int soma (int a,int b) {

int resultado;

resultado = a + b; return (resultado);

}

Para chamar a função: int x;

(6)

Exemplo

#include <stdio.h> #include <stdlib.h>

int soma (int a, int b);

main () {

int x=soma(10, 20);

printf ("\nA soma eh %d\n", x); system("pause");

}

int soma(int a,int b) {

int resultado;

resultado = a + b; return (resultado); }

(7)

Exemplo

main () {

int x=soma(10, 20);

}

int resultado;

Protótipo da função:

tipo de retorno: int

nome da função: soma parâmetros: 2

int a int b

(8)

Exemplo

main () {

int x=soma(10, 20);

}

int soma(int a,int b) { int resultado; resultado = a + b; return (resultado); } Chamada da função 2 argumentos: 10 e 20 retorno: x, do tipo int

(9)

Exemplo

main () {

int x=soma(10, 20);

}

int resultado;

Corpo da função

recebe os dados nos parâmetros a e b calcula soma e armazena em resultado retorna resultado, do tipo int

(10)

• O

tipo

na definição da função especifica o tipo

do resultado que será devolvido ao final da

execução da função.

• O tipo

void

pode ser usado para declarar

funções que não

retornam valor algum

.

• O nome da função é qualquer identificador

válido.

– A lista de parâmetros é uma lista, separada por

vírgulas, de variáveis com seus tipos associados.

– É possível que existam funções que não tenham lista

de parâmetros, mas ainda assim é necessário que os

parênteses sejam usados.

(11)

Protótipo de função

• Protótipos de funções ajudam a detectar

erros antes que eles ocorram, impedindo

que funções sejam chamadas com

argumentos inconsistentes.

• A forma geral de definição de um protótipo

é a seguinte:

(12)

Protótipo de função

• A

chamada

a uma função deve vir, a

princípio,

após sua definição

, para o

compilador conhecer os tipos de

parâmetros e o tipo de retorno da função.

– Porém, você pode chamar a função

antes

da

definição desta.

– Para isso declare apenas um

protótipo

da

função, o qual tem apenas o valor de retorno

e os parâmetros da função.

(13)

Uso da função

int soma(int a,int b) { int resultado; resultado = a + b; return(resultado); } main(){

int num1, num2, x;

printf ("\nInforme o primeiro numero: "); scanf ("%d",&num1);

printf ("\nInforme o segundo numero: "); scanf ("%d",&num2);

x=soma(num1,num2);

printf ("\nO resultado da soma eh %d\n", x); system("pause");

Sem protótipo da função e código da função

(definição) antes do main (antes da chamada)

(14)

Uso da função

#include <stdio.h> #include <stdlib.h> int soma(int a, int b); main(){

int num1, num2, x;

x=soma(num1,num2);

}

int resultado;

resultado = a + b; return(resultado); }

Com protótipo da função e código da função (definição) depois do main (depois

da chamada)

Chamada da função

(15)

Uso da função

main(){

int num1, num2, x;

x=soma(num1,num2);

}

int resultado;

resultado = a + b; return(resultado);

Sem protótipo da função e código da função

(definição) depois do main (depois da chamada): Erro!!!

Não encontra a função soma

(16)

Outro exemplo – sem retorno

#include <stdio.h> #include <stdlib.h> void fat(int n); main() { int n;

printf ("\nDigite o numero q vc deseja fatorar: "); scanf ("%d",&n);

fat(n);

system("pause"); }

void fat (int n) { int i; int f=1; for (i=1;i<=n;i++) f=f*i; printf ("\nFatorial de %d eh %d\n", n, f); }

(17)

Com retorno

#include <stdio.h> #include <stdlib.h> int fat(int n); main() { int n, x;

printf ("\nDigite o numero q vc deseja fatorar: "); scanf ("%d",&n);

x=fat(n);

printf ("\nFatorial de %d eh %d\n", n, x); system("pause");

}

int fat (int n) { int i; int f=1; for (i=1;i<=n;i++) f=f*i; return f;

(18)

Variáveis em funções

• As variáveis criadas numa função são

locais, assim serão destruídas após o

término da função.

• Caso você queira manter o valor

de uma

variável entre as chamadas

a uma função

você deve declarar esta variável como

static

.

(19)

int soma_1(int a);

main() {

int nr = 1;

printf("Chamando a funcao a primeira vez: valor + 1 = %d\n", soma_1(nr));

printf("Chamando a funcao pela segunda vez: : valor + 1 = %d\n", soma_1(nr)); printf("Chamando a funcao pela terceira vez: : valor + 1 = %d\n", soma_1(nr)); system("pause");

}

int soma_1(int a) {

static int valor = 1;

printf("\n\n\nvalor = %d\n",valor); valor = valor + a;

return(valor);

(20)

(21)

Sem static

int soma_1(int a);

main() {

int nr = 1;

printf("Chamando a funcao a primeira vez: valor + 1 = %d\n", soma_1(nr));

printf("Chamando a funcao pela segunda vez: : valor + 1 = %d\n", soma_1(nr)); printf("Chamando a funcao pela terceira vez: : valor + 1 = %d\n", soma_1(nr)); system("pause"); } int soma_1(int a) { int valor = 1; printf("\n\n\nvalor = %d\n",valor); valor = valor + a; return(valor);

(22)

(23)

Escopo de Variáveis

• Variáveis podem ser usadas dentro de uma função

particular

• Pode ocorrer que uma ou mais variáveis precisem ser

acessíveis à diversas funções diferentes.

• As variáveis podem ser declaradas basicamente em três

lugares: dentro de funções, fora de todas as funções

(globais) e na lista de parâmetros das funções

– As variáveis

dentro das funções

são chamadas de variáveis

locais

– As que aparecem

fora de todas as funções

chamamos de

variáveis

globais

– Aquelas que aparecem na lista de

parâmetros

são os

(24)

Variáveis Locais

• São aquelas

declaradas dentro de uma função

.

• Passam a existir quando do início da execução

do bloco de comandos ou função onde foram

definidas e são

destruídas ao final da execução

do bloco.

• Uma variável local só pode ser referenciada, ou

seja,

usada, dentro das funções

onde foram

declaradas.

• Como as variáveis locais deixam de existir ao

final da execução da função, elas são

invisíveis

(25)

Variáveis Globais

• São definidas fora de qualquer função

– e são portanto

disponíveis para qualquer função

.

• Este tipo de variável pode servir como uma

canal de comunicação entre funções, uma

maneira de transferir valores entre elas.

• Por exemplo, se duas funções têm de partilhar

dados, mas uma não chama a outra, uma

(26)

Variáveis Globais (2)

• Uma variável global é

visível a todas as

funções

• Todas as funções podem alterar ou

acessar o valor da variável diretamente

• Devem ser usadas com critério

– Pode criar alto grau de interdependência

entre as funções

• Dificultando o entendimento e a reutilização do

código

(27)

Variáveis Globais (3)

int s, p; //variaveis globais: declaradas ao inicio do codigo ou antes do main

void somaProd (int a, int b) { s=a+b; p=a*b; } main() { int x,y;

printf ("\nDigite 2 numeros: "); scanf ("%d %d", &x,&y);

somaProd(x,y);

printf ("\nA soma eh %d e o prod eh %d\n", s, p); system("pause");

(28)

• Caso uma variável local em uma função

tenha o mesmo nome de uma variável

global, a variável local será usada e não a

global.

(29)

int a = 1; /* variável global */

void exibe(void) {

int a = 10; /* variável local a função exibe() */ printf("a dentro da funcao = %d\n",a);

}

main() {

printf("\n");

printf("a global = %d\n",a); exibe();

printf("\n");

system("pause"); }

(30)

Parâmetros Formais

(31)

Argumentos e parâmetros

• Argumentos

são os valores usados

para chamar

a função

• Parâmetros

são as variáveis, declaradas na

definição da função, que

recebem

estes

argumentos.

– Os parâmetros são valores que a função recebe para

realizar as tarefas para as quais foi programada.

• uma função que calcule a raiz quadrada de um número do

tipo float, deve declarar como parâmetro uma variável deste

tipo para receber o valor

• Os tipos dos argumentos devem ser

(32)

int soma(int a, int b) /* "a" e "b" são os parâmetros da função "soma" */

{ int resultado; resultado = a + b; return(resultado); } main() {

printf("A soma entre 5 e 2 eh %d\n", soma(5,2));

/* No comando printf acima a função "soma" é chamada com os argumentos 5 e 2 */

system("pause"); }

(33)

• Declaração de parâmetros em funções:

TIPO NOME (TIPO PARÂMETRO1, TIPO PARÂMETRO2,

... , TIPO PARÂMETROn)

{

CORPO DA FUNÇÃO

}

Parâmetros

int soma(int a, int b) {

int resultado;

resultado = a + b; return(resultado);

(34)

Parâmetros

• As variáveis que aparecem na lista de parâmetros da

função são chamadas de parâmetros formais da função.

• São criados no início da execução da função e

destruídos no final.

• Parâmetros são

valores que as funções recebem

da

função que a chamou.

– os parâmetros permitem que uma função passe valores para

outra.

• As variáveis que atuam como parâmetros são iguais a

todas as outras e podem ser modificadas, operadas, etc,

sem nenhuma restrição.

(35)

Parâmetros

• É importante notar que diferentemente de

declarações de variáveis, onde podemos

associar vários nomes de variáveis a uma

declaração como em

– int a, dia, mes, i;

na lista de parâmetros é necessário

associar um tipo a cada variável como no

exemplo abaixo:

(36)

• É importante notar que

– os tipos e o número de parâmetros que

aparecem na declaração da função e na sua

chamada devem estar na mesma ordem e ter

tipos equivalentes.

(37)

Passagem de parâmetros

• Parâmetros podem ser passados para

funções de duas maneiras:

– passagem por valor

(38)

Passagem de parâmetros

• Parâmetros podem ser passados para

funções de duas maneiras:

– passagem por valor

(39)

Passagem por valor/chamada por

valor

• é a passagem normal do valor dos

argumentos para a função.

• os valores dos argumentos passados não

são modificados.

– na realidade é

passada uma cópia

dos

valores para a função.

• a função que recebe este valor, ao fazer

modificações no parâmetro,

não estará

alterando o valor original

(que somente

existe na função que chamou).

(40)

#include <stdio.h> #include <stdlib.h> int valor(int a, int b)

{

a = a + 3; /* Modificando o primeiro argumento */ b = b + 2; /* Modificando o segundo argumento */ printf("Valores modificados dentro da funcao:\n"); printf("nr1 = %d\n",a); printf("nr2 = %d\n",b); } int main() { int nr1 = 2, nr2 = 3, total; printf("\n");

printf("Chamada por valor\n"); printf("=================\n"); printf("Valores iniciais de nr1 e nr2\n"); printf("nr1 = %d\n",nr1); printf("nr2 = %d\n",nr2); printf("\n\nChamando a funcao\n"); valor(nr1,nr2);

printf("\n\nValores apos a chamada da funcao\n"); printf("nr1 = %d\n",nr1);

printf("nr2 = %d\n",nr2); system("pause");

(41)

//por referencia

//por referencia #include <stdio.h> #include <stdlib.h> int valor(int* a, int* b) {

*a = *a + 3; /* Modificando o primeiro argumento */ *b = *b + 2; /* Modificando o segundo argumento */ printf("Valores modificados dentro da funcao:\n"); printf("nr1 = %d\n",*a); printf("nr2 = %d\n",*b); } int main() { int nr1 = 2, nr2 = 3, total; printf("\n");

printf("Chamada por referencia\n"); printf("=================\n"); printf("Valores iniciais de nr1 e nr2\n"); printf("nr1 = %d\n",nr1); printf("nr2 = %d\n",nr2); printf("\n\nChamando a funcao\n"); valor(&nr1,&nr2);

printf("\n\nValores apos a chamada da funcao\n"); printf("nr1 = %d\n",nr1);

printf("nr2 = %d\n",nr2); system("pause");

(42)

O comando return

• é usado para

retornar o valor calculado

para a

função que chamou.

• Qualquer expressão pode aparecer no

comando, que tem a a seguinte forma geral:

– return expressão

• A função que chamou é livre para ignorar o

valor retornado

• A função pode não conter o comando return

– e portanto nenhum valor é retornado

• neste caso a função termina quando o último comando da

função é executado

(43)

float total(float preco, float taxa_juros) {

float preco_final, juros;

juros = preco * (taxa_juros / 100); preco_final = preco + juros;

return(preco_final);

} main()

{

float preco, taxa_juros, preco_final; printf("\n"); printf("Preco na etiqueta: "); scanf("%f",&preco); printf("\n"); printf("Taxa de juros: "); scanf("%f",&taxa_juros);

preco_final = total(preco, taxa_juros); printf("\n");

printf("Total a pagar : %4.2f\n\n",preco_final); system("pause");

(44)

• O valor retornado por return deve ser

compatível com o tipo da função, o qual é

definido quando da sua declaração.

– float total(float preco, float taxa_juros)

• No exemplo, a função total retorna um

valor float.

• Isto é determinado pela colocação do tipo

float antes do nome da função, como

(45)

• Se uma função não retornar nenhum valor

ela é do tipo void.

(46)

void nao_retorna() {

printf("Esta funcao nao retorna valor.\n"); } main() { nao_retorna(); system("pause"); }

• A função main devolve um inteiro para o processo

chamador, que geralmente é o sistema operacional. Isto

é equivalente a chamar exit com o mesmo valor. Alguns

compiladores ainda aceitam que main seja declarada

como void caso não retorne nenhum valor.

(47)

Outro exemplo

Faça um programa que leia dois números

inteiros e um caractere que identifica a

operação a ser feita entre eles (+, - ou *).

Use uma função que recebe os dois

números, verifica a operação, calcula o

resultado e retorna.

(48)

#include <stdio.h> #include <stdlib.h> #include <conio.h>

int calcula (int a, int b, char oper);

main(){

int numero1, numero2, resultado; char operacao;

printf ("\nDigite um numero inteiro: "); scanf ("%d", &numero1);

printf ("\nDigite um numero inteiro: "); scanf ("%d", &numero2);

printf ("\nInforme qual operacao vc quer realizar: (+, - ou *): "); operacao=getche();

if (operacao=='+' || operacao=='-' || operacao=='*') {

resultado=calcula(numero1, numero2, operacao);

printf ("\nA operacao realizada foi %c e o resultado eh %d\n", operacao, resultado); }

else

printf ("\nNao foi possivel calcular a operacao %c\n", operacao); system("pause");

}

int calcula (int a, int b, char oper) {

if (oper=='+') return a+b; else if (oper=='-') return a-b;

else if (oper=='*') return a*b; }