A maior rede de estudos do Brasil

Grátis
84 pág.
Aula 05 - Subrotinas - Funções e procedimentos

Pré-visualização | Página 1 de 4

DCC 119 Algoritmos
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.
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.
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.
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
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)
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) 
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.
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
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)
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.
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.
imprimeMaior(inteiro X, inteiro Y)
{
se (X > Y)
{ 
imprima(X);
}
senão
{ 
imprima(Y); 
}
}
imprimeMaior(inteiro X, inteiro Y)
{
se (X > Y)
{ 
imprima(X);
}
senão
{ 
imprima(Y); 
}
}
principal
{
inteiro A, B;
leia(A,B);
imprimeMaior(A,B);
}
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.
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. 
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
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
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
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
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
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
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
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
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
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
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
lixo1122lixo1122P6
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
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
lixo1122lixo1122P7
lixo1122lixo1122P6
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
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
lixo1122lixo1122P8
P9
P10
lixo1122lixo1122P7
lixo1122lixo1122P6
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
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
lixo1122lixo1122P8
2211221122P9
P10
lixo1122lixo1122P7
lixo1122lixo1122P6
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
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
lixo1122lixo1122P8
221122221122P9
P10
lixo1122lixo1122P7
lixo1122lixo1122P6
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
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