05.Subrotinas

Prévia do material em texto

Subrotinas
(Procedimentos e Funções)
DCC 119 – Algoritmos
Definição
Um conceito simples seria: 
Subrotina é um parcela de código 
computacional que executa uma tarefa bem 
definida, sendo que essa tarefa pode ser 
executada (chamada) diversas vezes num 
mesmo programa.
Motivação para criação
� Necessidade de dividir um problema computacional em 
pequenas partes.
� Os programadores verificaram que muitas destas 
pequenas partes se repetiam.
Ex.: Impressão de mensagens, zerar um vetor, fazer uma 
operação matricial, etc.
Utilização de subrotinas
Deve-se usar subrotinas sempre que:
� Utilizar uma parte do código em várias partes do 
programa; 
� Vários programas irão utilizar os mesmos códigos 
(bibliotecas); 
� Abstrair a complexidade e facilitar o entendimento do 
programa.
Utilização de subrotinas
Facilita a programação estruturada:
� dada as fases previstas nos refinamentos 
sucessivos decompõe-se o programa em módulos 
funcionais
� tais módulos podem ser organizados/programados 
como subrotinas
Ou seja: viabiliza a modularização
Características das subrotinas
� Executam uma tarefa bem definida
� Não funcionam sozinhas: devem ser chamadas por um 
programa principal ou por outra subrotina
� Permite a criação de variáveis próprias e a manipulação de 
variáveis externas (devidamente parametrizadas)
Características das subrotinas
� Facilita a legibilidade do código através da:
� estruturação (subrotinas são agrupadas fora do programa 
principal)
� enxugamento (através de diversas chamadas da mesma 
subrotina) 
Tipos de subrotinas
Existem dois tipos de subrotinas:
� Procedimentos: não retornam nenhum valor. São usadas 
para realizar alguma operação que não gera dados. 
� Funções: retornam valor. São utilizadas para realizar 
uma operação e retornam alguma resposta relativa à
operação realizada.
Procedimento - forma geral
A sintaxe de declaração de um procedimento é:
<nome do procedimento> (<lista de parâmetros>)
{
<declaração de variáveis locais>
<comandos>
}
Nome que identifique a ação a ser 
executada no procedimento (sem 
espaços em branco!)
Ex.: imprimeMedia
Procedimento - forma geral
A sintaxe de declaração de um procedimento é:
<nome do procedimento> (<lista de parâmetros>)
{
<declaração de variáveis locais>
<comandos>
}
Valores recebidos como parâmetro. 
Ex.: (A,B,20,30)
Procedimento - forma geral
A sintaxe de declaração de um procedimento é:
<nome do procedimento> (<lista de parâmetros>)
{
<declaração de variáveis locais>
<comandos>
} Variáveis necessárias para a 
codificação do procedimento, 
além das passados na lista de 
parâmetros.
Procedimento - forma geral
A sintaxe de declaração de um procedimento é:
<nome do procedimento> (<lista de parâmetros>)
{
<declaração de variáveis locais>
<comandos>
}
Comandos que implementam o 
procedimento desejado.
Procedimento - Exemplo
imprimeMaior(inteiro X, inteiro Y)
{
se (X > Y)
{ 
imprima(X);
}
senão
{ 
imprima(Y); 
}
}
Procedimento - chamada
imprimeMaior(inteiro X, inteiro Y)
{
se (X > Y)
{ 
imprima(X);
}
senão
{ 
imprima(Y); 
}
}
principal
{
inteiro A, B;
leia(A,B);
imprimeMaior(A,B);
}
Variáveis locais
Toda variável pertencente ao procedimento é
chamada de variável local, pois ela só pode ser 
utilizada dentro do escopo do procedimento.
Fazem parte das variáveis locais de um procedimento:
- as variáveis declaradas no procedimento; 
- todos os parâmetros recebidos pelo procedimento.
Parâmetros de uma subrotina
Chamada por valor: é passado uma cópia da variável para a 
subrotina, ou seja, é feito uma cópia do argumento para o parâmetro. 
Qualquer alteração feita no parâmetro não reflete em alteração no 
argumento.
Chamada por referência: todas as alterações realizadas no 
parâmetro, refletem em alterações no argumento, ou seja, ambas as 
variáveis apontam para o mesmo endereço de memória. Para isso, é
necessário utilizar o modificar ref, indicando que será uma referência 
a uma variável. 
Procedimento – teste de mesa
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z � X; 
}
senão
{ 
imprima(Y); 
Z � Y; 
}
}
principal
{
inteiro A, B, C;
A � 22; 
B � 11; 
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8’
P9’
P1
P2
P3
P4
P5
P10
P9’
P8’
P8
P9
P10
P7
P6
P5
P4
P3
P2
P1
ZYXCBA
imprimeMaiorprincipalLinha
Procedimento – teste de mesa
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z � X; 
}
senão
{ 
imprima(Y); 
Z � Y; 
}
}
principal
{
inteiro A, B, C;
A � 22; 
B � 11; 
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8’
P9’
P1
P2
P3
P4
P5
P10
P9’
P8’
P8
P9
P10
P7
P6
P5
P4
P3
P2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
Procedimento – teste de mesa
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z � X; 
}
senão
{ 
imprima(Y); 
Z � Y; 
}
}
principal
{
inteiro A, B, C;
A � 22; 
B � 11; 
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8’
P9’
P1
P2
P3
P4
P5
P10
P9’
P8’
P8
P9
P10
P7
P6
P5
P4
P3
---“lixo”“lixo”“lixo”P2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
Procedimento – teste de mesa
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z � X; 
}
senão
{ 
imprima(Y); 
Z � Y; 
}
}
principal
{
inteiro A, B, C;
A ���� 22; 
B � 11; 
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8’
P9’
P1
P2
P3
P4
P5
P10
P9’
P8’
P8
P9
P10
P7
P6
P5
P4
---“lixo”“lixo”22P3
---“lixo”“lixo”“lixo”P2
------P1
ZYXCBA
imprimeMaiorprincipal
Linha
Procedimento – teste de mesa
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z � X; 
}
senão
{ 
imprima(Y); 
Z � Y; 
}
}
principal
{
inteiro A, B, C;
A ���� 22; 
B ���� 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8’
P9’
P1
P2
P3
P4
P5
P10
P9’
P8’
P8
P9
P10
P7
P6
P5
---“lixo”1122P4
---“lixo”“lixo”22P3
---“lixo”“lixo”“lixo”P2
------P1
ZYXCBA
imprimeMaiorprincipal
Linha
Procedimento – teste de mesa
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z � X; 
}
senão
{ 
imprima(Y); 
Z � Y; 
}
}
principal
{
inteiro A, B, C;
A ���� 22; 
B ���� 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8’
P9’
P1
P2
P3
P4
P5
P10
P9’
P8’
P8
P9
P10
P7
P6
---“lixo”1122P5
---“lixo”1122P4
---“lixo”“lixo”22P3
---“lixo”“lixo”“lixo”P2
------P1
ZYXCBA
imprimeMaiorprincipal
Linha
Procedimento – teste de mesa
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z � X; 
}
senão
{ 
imprima(Y); 
Z � Y; 
}
}
principal
{
inteiro A, B, C;
A ���� 22; 
B ���� 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8’
P9’
P1
P2
P3
P4
P5
P10
P9’
P8’
P8
P9
P10
P7
“lixo”1122“lixo”1122P6
---“lixo”1122P5
---“lixo”1122P4
---“lixo”“lixo”22P3
---“lixo”“lixo”“lixo”P2
------P1
ZYXCBA
imprimeMaiorprincipal
Linha
Procedimento – teste de mesa
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y) // (22 > 11)
{ 
imprima(X);
Z � X; 
}
senão
{ 
imprima(Y); 
Z � Y; 
}
}
principal
{
inteiro A, B, C;
A ���� 22; 
B ���� 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8’
P9’
P1
P2
P3
P4
P5
P10
P9’
P8’
P8
P9
P10
“lixo”1122“lixo”1122P7
“lixo”1122“lixo”1122P6
---“lixo”1122P5
---“lixo”1122P4
---“lixo”“lixo”22P3
---“lixo”“lixo”“lixo”P2
------P1
ZYXCBA
imprimeMaiorprincipal
Linha
Procedimento – teste de mesa
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y) 
{ 
imprima(X); // imprima (22)
Z � X; 
}
senão
{ 
imprima(Y); 
Z � Y; 
}
}
principal
{
inteiro A, B, C;
A ���� 22; 
B ���� 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8’
P9’
P1
P2
P3
P4
P5
P10
P9’
P8’
“lixo”1122“lixo”1122P8
P9
P10
“lixo”1122“lixo”1122P7
“lixo”1122“lixo”1122P6
---“lixo”1122P5
---“lixo”1122P4
---“lixo”“lixo”22P3---“lixo”“lixo”“lixo”P2
------P1
ZYXCBA
imprimeMaiorprincipal
Linha
Procedimento – teste de mesa
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y) 
{ 
imprima(X); 
Z ���� X; // Z ���� 22
}
senão
{ 
imprima(Y); 
Z � Y; 
}
}
principal
{
inteiro A, B, C;
A ���� 22; 
B ���� 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8’
P9’
P1
P2
P3
P4
P5
P10
P9’
P8’
“lixo”1122“lixo”1122P8
2211221122P9
P10
“lixo”1122“lixo”1122P7
“lixo”1122“lixo”1122P6
---“lixo”1122P5
---“lixo”1122P4
---“lixo”“lixo”22P3
---“lixo”“lixo”“lixo”P2
------P1
ZYXCBA
imprimeMaiorprincipal
Linha
Procedimento – teste de mesa
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y) 
{ 
imprima(X); 
Z ���� X; // Z ���� 22
}
senão
{ 
imprima(Y); 
Z � Y; 
}
}
principal
{
inteiro A, B, C;
A ���� 22; 
B ���� 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8’
P9’
P1
P2
P3
P4
P5
P10
P9’
P8’
“lixo”1122“lixo”1122P8
221122221122P9
P10
“lixo”1122“lixo”1122P7
“lixo”1122“lixo”1122P6
---“lixo”1122P5
---“lixo”1122P4
---“lixo”“lixo”22P3
---“lixo”“lixo”“lixo”P2
------P1
ZYXCBA
imprimeMaiorprincipal
Linha
Procedimento – teste de mesa
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y) 
{ 
imprima(X); 
Z ���� X; 
}
senão
{ 
imprima(Y); 
Z ���� Y; 
}
}
principal
{
inteiro A, B, C;
A ���� 22; 
B ���� 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8’
P9’
P1
P2
P3
P4
P5
P10
P9’
P8’
“lixo”1122“lixo”1122P8
221122221122P9
P10
“lixo”1122“lixo”1122P7
“lixo”1122“lixo”1122P6
---“lixo”1122P5
---“lixo”1122P4
---“lixo”“lixo”22P3
---“lixo”“lixo”“lixo”P2
------P1
ZYXCBA
imprimeMaiorprincipal
Linha
Procedimento – teste de mesa
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y) 
{ 
imprima(X); 
Z ���� X; 
}
senão
{ 
imprima(Y); 
Z ���� Y; 
}
}
principal
{
inteiro A, B, C;
A ���� 22; 
B ���� 11;
imprimeMaior(A,B,C);
imprima(C); //imprima(22)
}
P6
P7
P8
P9
P8’
P9’
P1
P2
P3
P4
P5
P10
P9’
P8’
“lixo”1122“lixo”1122P8
221122221122P9
---221122P9
“lixo”1122“lixo”1122P7
“lixo”1122“lixo”1122P6
---“lixo”1122P5
---“lixo”1122P4
---“lixo”“lixo”22P3
---“lixo”“lixo”“lixo”P2
------P1
ZYXCBA
imprimeMaiorprincipal
Linha
Procedimentos em C
� Em C, para que uma subrotina atue como um 
procedimento devemos declarar algo do tipo:
void imprime (int val)
{ 
printf(“%d”,val);
}
Parâmetros de uma subrotina em C
� Passados através da lista de parâmetros
� Estes parâmetros podem ser cópia dos 
dados do programa (quando eles não serão 
alterados) ou pode-se permitir que a subrotina
altere os dados do programa diretamente.
Parâmetros de uma subrotina em C 
Exemplo
#include <stdio.h>
void ParImpar(int a)
{
int resto;
resto=a%2; 
if (resto==0) printf(“par”);
else printf( “ímpar”);
}
int main()
{
int x;
scanf(“%d”,&x);
ParImpar(x);
return 0;
}
Parâmetros de uma subrotina em C 
Exemplo
#include <stdio.h>
void ParImpar(int a)
{
int resto;
resto=a%2; 
if (resto==0) printf(“par”);
else printf( “ímpar”);
}
int main()
{
int x;
scanf(“%d”,&x);
ParImpar(x);
return 0;
}
Variáveis do main:
x
Parâmetros de uma subrotina em C 
Exemplo
#include <stdio.h>
void ParImpar(int a)
{
int resto;
resto=a%2; 
if (resto==0) printf(“par”);
else printf( “ímpar”);
}
int main()
{
int x;
scanf(“%d”,&x);
ParImpar(x);
return 0;
}
Variáveis locais:
a (cópia da variável x)
resto
Parâmetros de uma subrotina em C 
Exemplo
Chamada por valor: Qualquer alteração feita no parâmetro não 
reflete em alteração no argumento.
Chamada por referência: Todas as alterações realizadas no 
parâmetro, refletem em alterações no argumento, ou seja, ambas as 
variáveis apontam para o mesmo endereço de memória. Para isso, é
necessário que seja passado o endereço do argumento e o 
parâmetro receba-o na forma de ponteiro. 
Procedimento em C - Exemplo
imprimeMaior(inteiro X,
inteiro Y,
ref inteiro Z)
{
se (X > Y) 
{ 
imprima(X); 
Z ���� X; 
}
senão
{ 
imprima(Y); 
Z ���� Y; 
}
}
void imprimeMaior(int X, int Y, int *Z)
{
if (X > Y) 
{ 
printf(“%d”,X); 
*Z = X; 
}
else
{ 
printf(“%d”,Y);
*Z = Y; 
}
}
principal
{
inteiro A, B, C;
A ���� 22; 
B ���� 11; 
imprimeMaior(A,B,C);
imprima(C); 
}
main()
{
int A, B, C;
A = 22; 
B = 11; 
imprimeMaior(A,B,&C);
printf(“%d”,C);
}
Procedimento em C - Exemplo
Funções - forma geral
� É um tipo especial de procedimento
� Retorna como resultado o valor calculado pela 
função, que deve ser do tipo básico definido.
Funções - forma geral
A sintaxe de declaração de uma função é:
<tipo básico> <nome da função> (<lista de parâmetros formais>)
{
<declaração de variáveis locais>
<comandos>
retorne <valor de retorno>;
}
Tipo do dado a ser retornado 
como resultado da execução 
da função.
Funções - forma geral
A sintaxe de declaração de uma função é:
<tipo básico> <nome da função> (<lista de parâmetros formais>)
{
<declaração de variáveis locais>
<comandos>
retorne <valor de retorno>;
}
Nome que identifique a ação a ser executada 
na função (sem espaços em branco!)
Ex.: calculaMedia
Funções - forma geral
A sintaxe de declaração de uma função é:
<tipo básico> <nome da função> (<lista de parâmetros formais>)
{
<declaração de variáveis locais>
<comandos>
retorne <valor de retorno>;
}
Valores recebidos como parâmetro. 
Ex.: (A,B,20,30)
Funções - forma geral
A sintaxe de declaração de uma função é:
<tipo básico> <nome da função> (<lista de parâmetros formais>)
{
<declaração de variáveis locais>
<comandos>
retorne <valor de retorno>;
}
Declaração das variáveis 
locais e sequencia de 
comandos para a realização 
da função.
Funções - forma geral
A sintaxe de declaração de uma função é:
<tipo básico> <nome da função> (<lista de parâmetros formais>)
{
<declaração de variáveis locais>
<comandos>
retorne <valor de retorno>;
}
A função permite retornar um valor, resultado das ações 
nela programadas. Este valor deve ser do <tipo 
básico> declarado antes do nome da função.
Funções – exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X ≥ 0)
{
Y � X;
}
senão
{
Y � - X; 
}
retorne Y;
}
principal
{
real A,D;
A � -40;
D � valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8’
P9
P1
P2
P3
P4
P10
P10
P9
P8’
P8
P7
P6
P5
P4
P3
P2
P1
YXDA
valorAbsolutoprincipal
Linha
Funções – exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X ≥ 0)
{
Y � X;
}
senão
{
Y � - X; 
}
retorne Y;
}
principal
{
real A,D;
A � -40;
D � valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8’
P9
P1
P2
P3
P4
P10
P10
P9
P8’
P8
P7
P6
P5
P4
P3
P2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções – exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X ≥ 0)
{
Y � X;
}
senão
{
Y � - X; 
}
retorne Y;
}
principal
{
real A,D;
A � -40;
D � valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8’
P9
P1
P2
P3
P4
P10
P10
P9
P8’
P8
P7
P6
P5
P4
P3
--“lixo”“lixo”P2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções – exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X ≥ 0)
{
Y � X;
}
senão
{
Y � - X; 
}
retorne Y;
}
principal
{
real A,D;
A ���� -40;
D � valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8’
P9
P1
P2
P3
P4
P10
P10
P9
P8’
P8
P7
P6
P5
P4
--“lixo”-40P3
--“lixo”“lixo”P2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções – exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X ≥ 0)
{
Y � X;
}
senão
{
Y � - X; 
}
retorne Y;
}
principal
{
real A,D;
A ���� -40;
D ���� valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8’
P9
P1
P2
P3
P4
P10
P10
P9
P8’
P8
P7
P6
P5
--???-40P4
--“lixo”-40P3
--“lixo”“lixo”P2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções – exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X ≥ 0)
{
Y � X;
}
senão
{
Y � - X; 
}
retorne Y;
}
principal
{
real A,D;
A ���� -40;
D ���� valorAbsoluto(A);imprima (D);
}
P5
P6
P7
P8
P8’
P9
P1
P2
P3
P4
P10
P10
P9
P8’
P8
P7
P6
--40???-40P5
--???-40P4
--“lixo”-40P3
--“lixo”“lixo”P2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções – exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X ≥ 0)
{
Y � X;
}
senão
{
Y � - X; 
}
retorne Y;
}
principal
{
real A,D;
A ���� -40;
D ���� valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8’
P9
P1
P2
P3
P4
P10
P10
P9
P8’
P8
P7
“lixo”-40???-40P6
--40???-40P5
--???-40P4
--“lixo”-40P3
--“lixo”“lixo”P2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções – exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X ≥ 0) // (-40 ≥ 0) 
{
Y � X;
}
senão
{
Y � - X; 
}
retorne Y;
}
principal
{
real A,D;
A ���� -40;
D ���� valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8’
P9
P1
P2
P3
P4
P10
--40???-40P5
“lixo”-40???-40P6
P10
P9
P8’
P8
“lixo”-40???-40P7
--???-40P4
--“lixo”-40P3
--“lixo”“lixo”P2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções – exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X ≥ 0) // (-40 ≥ 0)
{
Y ���� X;
}
senão
{
Y � - X; 
}
retorne Y;
}
principal
{
real A,D;
A ���� -40;
D ���� valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8’
P9
P1
P2
P3
P4
P10
--40???-40P5
“lixo”-40???-40P6
P10
P9
P8’
P8
“lixo”-40???-40P7
--???-40P4
--“lixo”-40P3
--“lixo”“lixo”P2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções – exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X ≥ 0) // (-40 ≥ 0)
{
Y ���� X;
}
senão
{
Y ���� - X; 
}
retorne Y;
}
principal
{
real A,D;
A ���� -40;
D ���� valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8’
P9
P1
P2
P3
P4
P10
--40???-40P5
“lixo”-40???-40P6
P10
P9
40-40???-40P8’
P8
“lixo”-40???-40P7
--???-40P4
--“lixo”-40P3
--“lixo”“lixo”P2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções – exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X ≥ 0) // (-40 ≥ 0)
{
Y ���� X;
}
senão
{
Y ���� - X; 
}
retorne Y;
}
principal
{
real A,D;
A ���� -40;
D ���� valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8’
P9
P1
P2
P3
P4
P10
--40???-40P5
“lixo”-40???-40P6
P10
40-4040-40P9
40-40???-40P8’
P8
“lixo”-40???-40P7
--???-40P4
--“lixo”-40P3
--“lixo”“lixo”P2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções – exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X ≥ 0) // (-40 ≥ 0)
{
Y ���� X;
}
senão
{
Y ���� - X; 
}
retorne Y;
}
principal
{
real A,D;
A ���� -40;
D ���� valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8’
P9
P1
P2
P3
P4
P10
--40???-40P5
“lixo”-40???-40P6
P10
40-4040-40P9
40-40???-40P8’
P8
“lixo”-40???-40P7
--40-40P4
--“lixo”-40P3
--“lixo”“lixo”P2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções – exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X ≥ 0) // (-40 ≥ 0)
{
Y ���� X;
}
senão
{
Y ���� - X; 
}
retorne Y;
}
principal
{
real A,D;
A ���� -40;
D ���� valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8’
P9
P1
P2
P3
P4
P10
--40???-40P5
“lixo”-40???-40P6
40-40P10
40-4040-40P9
40-40???-40P8’
P8
“lixo”-40???-40P7
--40-40P4
--“lixo”-40P3
--“lixo”“lixo”P2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções em C
� Funções: retornam valor. São utilizadas para realizar 
uma operação e retornam alguma resposta relativa à
operação realizada.
� Exemplo:
int soma (int a, int b)
{
return (a+b);
}
Exercícios
1) Faça um procedimento que receba três valores
reais e imprima a média aritmética desses valores.
2) Faça uma função que receba um valor N inteiro e
positivo e que calcula o fatorial deste valor. 
Retorne o resultado.
3) Faça um procedimento que receba dois valores 
inteiros n1 e n2 e imprima o intervalo fechado 
entre esses dois valores. 
4) Faça uma função que receba dois valores inteiros 
n1 e n2 e retorne a quantidade de valores que 
existem entre eles que sejam divisíveis por 3 e 7.
Chamada por referência-exemplo
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf(“%d,%d,%d”,a,b,c);
return 0;
}
MemMemóóriaria
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf(“%d,%d,%d”,a,b,c);
return 0;
}
MemMemóóriaria
25
50
75
a
b
c
Chamada por referência-exemplo
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf(“%d,%d,%d”,a,b,c);
return 0;
}
MemMemóóriaria
25
50
75
a
b
c
Chamada por referência-exemplo
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf(“%d,%d,%d”,a,b,c);
return 0;
}
MemMemóóriaria
25
50
75
a
b
c
a1
b1
&a
&b
Chamada por referência-exemplo
MemMemóóriaria
25
50
75
a
b
c
a1
b1
aux25
&a
&b
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf(“%d,%d,%d”,a,b,c);
return 0;
}
Chamada por referência-exemplo
MemMemóóriaria
50
50
75
a
b
c
a1
b1
aux25
&a
&b
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf(“%d,%d,%d”,a,b,c);
return 0;
}
Chamada por referência-exemplo
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf(“%d,%d,%d”,a,b,c);
return 0;
}
MemMemóóriaria
50
25
75
a
b
c
a1
b1
aux25
&a
&b
Chamada por referência-exemplo
MemMemóóriaria
50
25
75
a
b
c
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf(“%d,%d,%d”,a,b,c);
return 0;
}
Chamada por referência-exemplo
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf(“%d,%d,%d”,a,b,c);
return 0;
}
MemMemóóriaria
50
25
75
a
b
c
a1
b1
&b
&c
Chamada por referência-exemplo
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf(“%d,%d,%d”,a,b,c);
return 0;
}
MemMemóóriaria
a
b
c
a1
b1
aux25
&b
&c
50
25
75
Chamada por referência-exemplo
MemMemóóriaria
75
a
b
c
a1
b1
aux25
&b
&c
50
75
75
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf(“%d,%d,%d”,a,b,c);
return 0;
}
Chamada por referência-exemplo
MemMemóóriaria
a
b
c
a1
b1
aux25
&b
&c
50
75
25
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf(“%d,%d,%d”,a,b,c);
return 0;
}
Chamada por referência-exemplo
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf(“%d,%d,%d”,a,b,c);
return 0;
}
MemMemóóriaria
a
b
c
50
75
25
Chamada por referência-exemplo
Exercícios (continuação)
5) O que será impresso no programa abaixo?
#include <stdio.h>
void calculo (int *p, int *q)
{
*p = *p * 10;
*q = *q + 10;
}
int main()
{
int x = 2, y = 5;
calculo(&x,&y);
printf("%d - %d",x,y);
return 0;
}
Exercícios
6) Qual a saída do programa abaixo:
#include <stdio.h>
int calculo (int p, int q)
{
p = p * 10;
q = q + 10;
return(p + q);
}
intmain()
{
int x = 2, y = 5;
printf(“%d %d %d”,x,y,calculo(x,y));
return 0;
}
Exercícios
7) Qual a saída do programa abaixo:
#include <stdio.h>
int calculo (int p, int *q)
{
p = p * 10;
*q = *q + 10;
return(p);
}
int main()
{
int x = 2, y = 5, z;
z = calculo(x,&y);
printf(“%d %d %d”,x,y,z);
return 0;
}
Exercícios
8) Qual a saída do programa abaixo:
#include <stdio.h>
int cal(int p, int *q, int *r)
{
p = p * 10;
*q = *q + 10;
*r = *r - 10;
return(p);
}
int main()
{
int x = 2, y = 5, z = 3, r;
r = cal(x,&y,&z);
printf(“%d %d %d %d”,x,y,z,r);
return 0;
}
Subrotinas
DCC 120
REVISÃO: Forma Geral
A forma geral de uma subrotina é:
especificador_tipo nome ( lista parâmetros )
{
corpo da subrotina;
return xxx;
}
REVISÃO: Tipos de Subrotinas
� procedimentos
void ImprimeSoma (int a, int b)
{ 
printf(“%d”, a+b); 
}
� funções
int Soma (int a, int b)
{ 
return (a+b); 
}
Variações na implementação de 
subrotinas em C
#includes.....
int Func1(int a)
{
........
}
main()
{
......
x=Func1(10);
.....
}
#includes.....
int Func1(int a); //protótipo
main()
{
......
x=Func1(10);
.....
}
int Func1(int a)
{
........
}
Parâmetros de uma subrotina em C 
Exemplo
Chamada por valor: Qualquer alteração feita no parâmetro não 
reflete em alteração no argumento.
Chamada por referência: Todas as alterações realizadas no 
parâmetro, refletem em alterações no argumento, ou seja, ambas as 
variáveis apontam para o mesmo endereço de memória. Para isso, é
necessário que seja passado o endereço do argumento e o 
parâmetro receba-o na forma de ponteiro. 
Escreva um programa que leia a matrícula de um aluno e suas três notas. Calcule a média 
desse aluno e mostre, ao final, a média calculada e uma mensagem "APROVADO" se a média 
for maior ou igual a 6 e "REPROVADO" caso contrário. O cálculo da média e as impressões 
devem ser feitos por um procedimento. Repita a operação até que uma matrícula negativa 
seja lida.
void calculaMedia(float nota1, float nota2, float nota3)
{
float media;
media = (nota1 + nota2 + nota3) / 3;
printf("Media = %.2f\n", media);
if(media >= 6)
printf("APROVADO\n");
else
printf("REPROVADO\n");
}
int main()
{
int matricula;
float n1, n2, n3;
printf("Digite a matricula do aluno: ");
scanf("%d", &matricula);
while(matricula >= 0)
{
printf("Digite as 3 notas: ");
scanf("%f %f %f", &n1, &n2, &n3);
calculaMedia (n1, n2, n3);
printf("Digite a matricula do aluno: ");
scanf("%d", &matricula);
}
return 0;
}
Exemplo completo usando PROCEDIMENTO – Chamada por valor
int quadrado (int x)
{
return (x * x);
}
int main ()
{
int numero, res;
printf("Digite um numero inteiro: ");
scanf("%d", &numero);
while(numero != 0)
{
res = quadrado(numero);
printf ("O quadrado de %d eh %d.\n", numero, res);
printf("Digite um numero inteiro: ");
scanf("%d", &numero);
}
return 0;
}
Exemplo completo usando Função – Chamada por Valor
Escreva uma programa que calcule e imprima o quadrado de um número. O cálculo 
deve ser feito por uma função. Repita a operação até que seja lido um número igual 
a zero.
Exemplo completo usando Procedimento – Chamada por referência
Escreva um procedimento que receba duas variáveis reais e troque o valor da 
primeira pela segunda. Faça uma função principal para testar este procedimento.
#include <stdio.h>
void troca(float *a1, float *b1)
{
float aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
float a=12.0, b=17.8;
printf("Valores originais: %.2f, %.2f\n", a, b);
troca(&a,&b);
printf("Valores trocados: %.2f, %.2f\n", a, b);
return 0;
}
Exercícios
1) Escreva um procedimento que receba como 
parâmetro dois valores inteiros n1 e n2 e imprima 
o intervalo fechado entre eles, do menor para o 
maior.
Por exemplo: se n1 = 2 e n2 = 5, o procedimento 
irá imprimir 2, 3, 4, 5.
2) Faça um procedimento que receba por parâmetro o 
tempo de duração de um experimento expresso 
em segundos e imprima na tela esse mesmo 
tempo em horas, minutos e segundos. 
3) Faça uma função que receba por parâmetro o raio 
de uma esfera e calcula o seu volume:
v = (4 * PI * R3) /3. 
4) Faça uma função que receba a idade de uma 
pessoa em anos, meses e dias e retorna essa 
idade expressa em dias.
Exercícios
5) Faça um programa que apresente o seguinte “Menu” para o usuário:
Escolha uma opção de cálculo para dois números:
1) Soma
2) Produto
3) Quociente
4) Sair
Opção:__ 
O “Menu” acima deve ser apresentado para o usuário enquanto ele não 
escolher a opção 4 (sair do programa). O usuário fornecerá 2 
números se escolher as opções de cálculo 1, 2 ou 3. Para cada 
opção de cálculo deve existir (obrigatoriamente) uma função definida 
(soma, produto e quociente dos dois números fornecidos pelo 
usuário). O resultado do cálculo deve ser escrito na tela.
Exercícios
6) Idem ao exercício 5, agora com o seguinte “Menu”
Escolha uma opção de cálculo para um número:
a) Fatorial
b) Exponencial
c) Raiz quadrada
d) Sair
Opção: __ 
Nas opções “b” e “c” pode-se utilizar funções predefinidas do C.