O documento descreve os conceitos de subalgoritmos, subprogramas e subrotinas. Explica que subprogramas/subalgoritmos podem realizar tarefas específicas como aceitar dados, realizar cálculos e devolver resultados. Também descreve que um subprograma é chamado por um programa principal para executar uma tarefa específica e depois devolver o controle ao programa principal.

1. PROCEDIMENTOS
Profª Ms. Engª Elaine Cecília Gatto
Curso de Bacharelado em Engenharia de Computação
Universidade do Sagrado Coração – USC
Bauru/SP

2. SubAlgoritmos
• DIVIDIR PARA CONQUISTAR:
• Método para resolução de problemas que consiste
em dividir um problema, em problemas menores e
mais fáceis de solucionar.
• PROJETO DESCENDENTE (TOP-DOWN DESIGN):
• Método de projetar a solução de um problema
principal obtendo soluções de seus subproblemas.
• As partes em que se divide um programa devem ser
desenvolvidas independentemente umas das outras

3. SubAlgoritmos
ALGORITMO
PRINCIPAL
SUBALGORITMO 1
SUBALGORITMO 2
SUBALGORITMO 3
PROGRAMA
PRINCIPAL
SUBPROGRAMA1
SUBPROGRAMA 2
SUBPROGRAMA 3

4. SubAlgoritmos
• Um subprograma/subalgoritmo pode realizar
as mesmas ações que um programa:
1. Aceitar dados
2. Realizar alguns cálculos
3. Devolver resultados

5. SubAlgoritmos
• Entretanto, um subprograma é utilizado por um
programa para um propósito específico.
• O programa
subprograma.
principal
chama
ou
invoca
um
• O subprograma, quando invocado, obtém o controle,
executa sua tarefa e devolve o controle ao programa
principal.
• Existem dois tipos de subprogramas: FUNÇÕES e
PROCEDIMENTOS.

6. SubAlgoritmos
PROGRAMA
PRINCIPAL
--------------------ALGORITMO
Chamada 1
Retorno 1
Chamada 2
Retorno 2
SUBPROGRAMA
-------------------------SUBALGORITMO

7. SubAlgoritmos
Chamada 1
Retorno 1
SUBPROGRAMA 1
Chamada 2
PROGRAMA
PRINCIPAL
Retorno 2
SUBPROGRAMA 2
SUBPROGRAMA 3
SUBPROGRAMA 2.1

8. FUNÇÕES
•

9. FUNÇÕES
•

10. SUB-ROTINA
• O mesmo que subprogramas ou funções
• São blocos de instruções que realizam tarefas
específicas
• O código é carregado uma vez e pode ser
executado várias vezes
• Os programas
organizados
ficam
menores
e
mais

11. SUB-ROTINA
• Em linguaguens estruturadas, os programas são
executados linearmente, LINHA APÓS LINHA
• Subrotinas permitem um desvio nesta execução
• A ordem da execução das instruções do
programa é desviada quando existe a chamada
de uma rotina no programa principal

12. SUB-ROTINA
• Enquanto a subrotina é executada, o
programa principal fica suspenso
• O controle volta ao programa principal
quando a execução da subrotina chega ao seu
fim, por meio da palavra chave RETURN

13. SUB-ROTINA
• Variáveis locais: variáveis declaradas dentro
das subrotinas. São destruídas assim que a
execução da rotina é finalizada.
• Variaveis globais: variáveis declaradas dentro
do programa principal. Qualquer ponto do
programa pode usá-las. São destruídas
quando a execução do programa é finalizado

14. SUB-ROTINA
• Passagem por valor: quando um parâmetro é
passado para a função. A variável do
cabeçalho se comportará como uma variável
local da subrotina
• Passagem por referência: quando um
parâmetro é passado para a função. A
variável do cabeçalho se comportará como
uma variável global.

15. SUB-ROTINA
Algoritmo exemplo1;
Inteiro : sal, aum, novo_sal;
Leia(sal)
Aum  calculo(sal);
Novo_sal  sal + aum;
Escreva(“Novo Salário é: ”, novo_sal);
FIM.
Subrotina calculo(inteiro: sal)
Inteiro : perc, valor;
Leia(perc);
Valor  (sal * perc) / 100;
Retorne valor
Fim_subrotina calculo

16. SUB-ROTINA
Algoritmo exemplo2;
Inteiro : x, y;
X <-- 1;
Y  2;
Escreva( “ valores iniciais ” );
Escreva( “ x = ”, z, “ y ”, = y );
S1;
Escreva( “ valores depois da execução da s1” );
Escreva( “ x = ”, z, “ y ”, = y );
S2( x, y ); //por valor
Escreva( “ valores depois da execução da s2” );
Escreva( “ x = ”, z, “ y ”, = y );
S3( x, y ); //por referência
Escreva( “ valores depois da execução da s3” );
Escreva( “ x = ”, z, “ y ”, = y );
FIM.

17. SUB-ROTINA
//subrotina sem parâmetro e sem retorno
Subrotina s1
Inteiro : x, y, z; //variáveis locais
X  8;
Y  10;
Z  5;
Escreva( “Valores impressos dentro da subrotina s1”
);
Escreva( “ x = ”, x, “ y = ”, y, “ z = ”, z );
FIM_Subrotina_S1;

18. SUB-ROTINA
//subrotina com parâmetro por valor e sem retorno
Subrotina s2 ( inteiro : x, y )
Inteiro : z; //variáveis locais
X  x + 2;
Y  y + 2;
Z  x + y;
Escreva( “ Valores impressos dentro da subrotina
s2” );
Escreva( “ x = ”, x, “ y = ”, y, “ z = ”, z );
FIM_Subrotina_S2;

19. SUB-ROTINA
//subrotina com parâmetro por referência e sem
retorno
Subrotina s3 ( inteiro : x, y )
Inteiro : a; //variáveis locais
A  x + y;
X  y - 1;
Y  x - 2;
Escreva( “ Valores impressos dentro da subrotina
s2” );
Escreva( “ x = ”, x, “ y = ”, y, “ a = ”, z );
FIM_Subrotina_S2;

20. Modularização
• Pascal permite o uso de:
• PROCEDURES – procedimentos
• FUNCTIONS – funções
• UNITS – unidades
• São três formas de modularizar um programa
• Procedures e functions devem ter o seu
código escrito antes do BEGIN

21. PROCEDURES

22. SEM PASSAGEM DE
PARÂMETROS
• São rotinas chamadas pelo programa
principal para executar alguma operação
especí´fica, mas não retornam valor para
quem as chamou
Procedure nome_da_procedure;
Declaração_de_variáveis_locais;
Begin
Comandos
End;
P
R
O
C
E
D
U
R
E
S

23. SEM PASSAGEM DE
PARÂMETROS
Program exemplo;
Uses crt;
Var
a, b, s : integer //variáveis globais
Procedure somar;
Begin
s := a + b;
End;
P
R
O
C
E
D
U
R
E
S

24. SEM PASSAGEM DE
PARÂMETROS
Begin
clrscr;
writeln(‘Digite o primeiro numero’);
readln(a);
writeln(‘Digite o segundo numero’);
readln(b);
somar;
writeln(‘A soma é: ’, s);
readln();
End.
P
R
O
C
E
D
U
R
E
S

25. SEM PASSAGEM DE
PARÂMETROS
Program exemplo2;
Uses crt;
Procedure somar;
Var
a, b, s : integer;
Begin
writeln(‘digite o primeiro numero’);
readln(a);
P
R
O
C
E
D
U
R
E
S

26. SEM PASSAGEM DE
PARÂMETROS
Writeln(‘Digite o segundo numero’);
Readln(b);
s := a + b;
Writeln(‘A soma é: ’, s);
End;
Begin
Clrscr;
Somar;
Readln;
End.
P
R
O
C
E
D
U
R
E
S

27. PASSAGEM DE PARÂMETROS
POR VALOR
Alguns valores são fornecidos à procedure
quando ela é solicitada
Procedure nome_da_procedure(parâmetros :
tipo_dos_dados)
Declaração_de_variáveis_locais;
Begin
Comandos;
End;
P
R
O
C
E
D
U
R
E
S

28. PASSAGEM DE PARÂMETROS
POR VALOR
Program exemplo1;
Uses crt;
Var
A, b : integer;
Procedure somar(x, y : integer);
Var
S : integer;
begin
s := x + y;
writeln(‘A soma é: ’, s);
end;
P
R
O
C
E
D
U
R
E
S

29. PASSAGEM DE PARÂMETROS
POR VALOR
Begin
clrscr;
writeln(‘Digite o primeiro número’);
readln(a);
writeln(‘Digite o segundo número’);
readln(b);
somar(a, b);
readln;
End.
P
R
O
C
E
D
U
R
E
S

30. PASSAGEM DE PARÂMETROS
POR VALOR
Program exemplo2;
Uses crt;
//passando matriz ou vetor como parâmetro
Type x = array[1..5] of integer;
Var
i : integer;
w : x;
P
R
O
C
E
D
U
R
E
S

31. PASSAGEM DE PARÂMETROS
POR VALOR
Procedure mostrar(y:x);
Begin
Writeln(‘Mostrando o vetor na subrotina’);
For i:=1 to 5 do
Begin
Writeln( y [ i ] );
End;
End;
P
R
O
C
E
D
U
R
E
S

32. PASSAGEM DE PARÂMETROS
POR VALOR
Begin
clrscr;
writeln(‘digitando os números do vetor: ’);
for i:=1 to 5 do
Begin
readln( w [ i ] );
End;
mostrar(w);
readln;
End.
P
R
O
C
E
D
U
R
E
S

33. PASSAGEM DE PARÂMETROS
POR REFERÊNCIA
Os parâmetros se comportam como variáveis
globais
Procedure nome_da_procedure(VAR parâmetros :
tipo_dos_dados);
Declaração_de_variáveis_locais;
Begin
Comandos
End;
P
R
O
C
E
D
U
R
E
S

34. PASSAGEM DE PARÂMETROS
POR REFERÊNCIA
Program exemplo1;
Uses crt;
Var
a, b : integer;
Procedure somar(VAR x, y : integer);
Var
s : integer;
P
R
O
C
E
D
U
R
E
S

35. PASSAGEM DE PARÂMETROS
POR REFERÊNCIA
Begin
s := x + y;
writlen(‘A soma é: ’, s);
End;
Begin
clrscr;
writeln(‘Digite o primeiro número’);
readln(a);
P
R
O
C
E
D
U
R
E
S

36. PASSAGEM DE PARÂMETROS
POR REFERÊNCIA
writeln(‘Digite o segundo número’);
readln(b);
somar(a, b);
readln;
End.
P
R
O
C
E
D
U
R
E
S

37. FUNCTIONS

38. SEM PASSAGEM DE
PARÂMETRO
•
•
•
•
FUNCTION X PROCEDURE
Function SEMPRE retorna um valor
A PROCEDURE NEM sempre retorna um valor
O OBJETIVO é para ambos é o mesmo
FUNCTION NOME_DA_FUNCTION :
TIPO_DE_DADO_DO_VALOR_RETORNADO;
Declaração_de_variáveis_locais;
Begin
Comandos;
End;
F
U
N
C
T
I
O
N
S

39. SEM PASSAGEM DE
PARÂMETRO
• Para que ocorra o retorno de algum valor para quem
chamou a function, deve-se atribuir tal valor a uma variável
cujo nome seria igual ao dado à function
Program exemplo1;
Uses crt;
Var
a, b, s : integer;
Function somar : integer;
begin
somar := a + b;
end;
F
U
N
C
T
I
O
N
S

40. SEM PASSAGEM DE
PARÂMETRO
Begin
Clrscr;
writeln(‘Digite o primeiro número’);
readln(a);
writeln(‘Digite o segundo número’);
readln(b);
s := somar;
writeln(‘ A soma é: ’, s);
readln;
End.
F
U
N
C
T
I
O
N
S

41. PASSAGEM DE PARÂMETRO
POR VALOR
FUNCTION nome_da_function(parâmetros : tipo_dos_dados)
: tipo_de_dado_do_valor_retornado;
Declaração_de_variáveis_locais;
Begin
Comandos;
End;
F
U
N
C
T
I
O
N
S

42. PASSAGEM DE PARÂMETRO
POR VALOR
• A chamada a uma FUNCTION acontece
atribuindo seu nome a uma variável ou a um
condição, que receberá o retorno ao término de
sua execução
• No momento da chamada, são informados os
parâmetros que deverão ser levados para a
FUNCTION
F
U
N
C
T
I
O
N
S

43. PASSAGEM DE PARÂMETRO
POR VALOR
Program exemplo1;
Uses crt;
Var
a, b, s : integer;
Function somar(x, y : integer) : integer;
Begin
Somar := x + y;
End;
F
U
N
C
T
I
O
N
S

44. PASSAGEM DE PARÂMETRO
POR VALOR
Begin
clrscr;
writeln(‘Digite o primeiro número’);
readln(a);
writeln(‘Digite o segundo número’);
readln(b);
s := somar(a, b);
writeln(‘ A soma é: ’, s);
readln;
End.
F
U
N
C
T
I
O
N
S

45. PASSAGEM DE PARÂMETRO
POR REFERÊNCIA
Uma function pode receber parâmetros no momento
em que é chamada
Os valors informados são copiados, sequencialmente,
em variáveis descritas em seu cabeçalho
FUNCTION nome_da_function( VAR parâmetros :
tipo_dos_dados ) : tipo_de_dado_do_valor_retornado;
Declaração de variáveis locais;
Begin
Comandos;
End;
F
U
N
C
T
I
O
N
S

46. PASSAGEM DE PARÂMETRO
POR REFERÊNCIA
Program exemplo1;
Uses crt;
Var
a, b, s : integer;
Function somar(VAR x, y : integer) : integer;
Begin
somar := x + y;
End;
F
U
N
C
T
I
O
N
S

47. PASSAGEM DE PARÂMETRO
POR REFERÊNCIA
Begin
clrscr;
writeln(‘Digite o primeiro número’);
readln(a);
writeln(‘Digite o segundo número’);
readln(b);
s := somar(a, b);
writeln(‘ A soma é: ’, s);
readln;
End.
F
U
N
C
T
I
O
N
S

48. PASSAGEM DE PARÂMETRO
POR REFERÊNCIA
• Os parâmetros passados por referência – isso
é identificado pela presença da palavra VAR
no cabeçalho da FUNCTION – qualquer
alteração nos valores de X ou de Y será
também refletida nas variáveis A e B,
respectivamente
F
U
N
C
T
I
O
N
S

49. UNITS
• É um arquivo (.pas)
• Contém várias procedures e functions
• Torna-se um TPU depois de ser compilado –
isto é, torna-se uma biblioteca
• A biblioteca pode ser chamada por outros
programas por meio do uso da palavra chave
USES
• O nome de uma UNIT deve ser o nome do
arquivo

50. UNITS
UNIT nome_da_unit;
INTERFACE
Cabeçalho das procedures e das functions;
IMPLEMENTATION
Implementação das procedures e das functions;
END;

51. UNITS
unit calcula;
interface
procedure somar(a, b : integer);
function multiplicar(a, b, c : integer) : integer;
Implementation
procedure somar(a, b : integer);
var
s : integer;
writeln(‘ A soma é : ’, s);
end;
function multiplicar(a, b, c : integer) : integer;
begin
multiplicar : = a * b * c;
end;
end.

52. UNITS
• Para criar uma UNIT (biblioteca) é necessário abrir um
arquivo novo, digitar os códigos da biblioteca e salvar o
arquivo com o mesmo nome da UNIT. Esse arquivo
será o .PAS.
• Depois, no menu COMPILAR, o destino da compilação
deve ser alteração para DISK. Somente depois disso
será gerado o arquivo TPU (que é a biblioteca
propriamente dita)

53. UNITS
Program subrotina;
Uses crt, calcula;
Var
x, y, z, mult : integer;
Begin
Clrscr;
Writeln(‘digite o valor de x’);
Readln(x);
Writeln(‘digite o valor ’);
Readln(y);
somar(x,y);
Writeln(‘digite o valor de z’);
readln(z);
mult := multiplicar(x, y, z);
writeln(‘multiplicação = ’, mult);
Readln;
End.

54. Exercícios