O documento discute conceitos fundamentais de modularização e programação estruturada, incluindo: 1) a divisão de problemas em módulos menores para facilitar o desenvolvimento e manutenção de programas; 2) a utilização de subprogramas para implementar cada módulo de forma independente; 3) a comunicação entre módulos através de parâmetros formais e reais.

1. ALGORITMOS
Rodrigo Kiyoshi Saito / rodrigok@anchieta.br

2. Modularização
• Modularização ou subprograma é um aspécto
fundamental da programação estruturada
(Staa, 2000).
• Um dos objetivos da programação estruturada
é diminuir a complexidade dos programas,
usando a estratégia de dividir os problemas
em menores pedaços;

3. Modularização
• Cada modulo deve ter um único objetivo, a
qual tem um ponto de entrada, executa e
termina em um ponto de saída;
• Cada modulo é implementado por um
sobprograma específico, passível de ser
construído e testado de forma independente;
• Os diferentes subprogramas são
posteriormente integrados em um só
programa;

4. Modularização
• Subprogramas tem o objetivo de facilitar a
compreensão, o desenvolvimento, o teste e a
manutenção dos sistemas;
• Programas que utilizam subprogramação
resultam mais confiáveis e flexíveis;

5. Modularização
Algoritimo NomePrograma
var
x, y, z : inteiro;
inicio
x = 1
leia y
se (x = y) então
execute SubPrograma1
senão
execute SubPrograma2
fim_se
leia z
se ( y = z) então
execute SubPrograma1
fim_se
fim
Procedimento SubPrograma1
var
a, b: inteiro;
inicio
a = 10
b = 20
imprima a, b
fim
Procedimento SubPrograma2
var
a, b: inteiro;
inicio
a = 5
b = 10
imprima b, a
fim

6. Modularização
• Um subprogramas (as vezes chamado de sub-
rotina) consiste de um trecho de Código com
estrutura semelhante a um programa, que é
executado somente quando acionado por
outro trecho de Código;
• Esse acionamento costuma-se denominar
chamada ao subprograma (ou subrotina);

7. Modularização
• Um subprograma deve executar uma única
tarefa, claramente definida;
• A execução correta de um subprograma deve
ser assegurada sempre que esse seja
adequadamente chamado;

8. Modularização
• A utilização de um subprograma é uma técnica
de programação que visa:
– A definição de trechos de códigos menores, mais
fáceis de serem construídos e testados;
– A diminuição do tamanho dos programas, pela
elininação de redundancias, ao evitar que códigos
semelhantes sejam repetidos dentro de um
programa;
– a reutilização de código em um programa ou em
programas diferentes ;

9. Modularização
– a construção mais segura de programas
complexos, pela utilização de unidades menores
(ou subprogramas) já construídas e testada;

10. Modularização
• Todo subprograma é identificado através de
um nome;
• Esse nome deve representar claramente a
tarefa a ser executada pelo subprograma;
• Com a chamada à um subprograma é feita
pelo seu nome, por um comando específico
ou utilizando diretamente seu resultado;

11. Modularização
• Quando um subprograma é chamado, o fluxo
de execução do programa ou subprograma
que o chamou é interrompido e o
subprograma passa a ser executado;
• Terminada a execução subsubprograma, o
fluxo de execução interrompido é retornado, e
o processamento segue a partir do ponto
imediatamente após a chamada concluída;

12. Modularização
• Um subprograma pode chamar outro
subprograma;
• A forma de execução é sempre a mesma: o
que chamou fica suspenso, esperando o
término dá execução do subprograma
chamado, continuando depois sua execução a
partir da instrução seguinte a instrução de
chamada o subprograma;

13. Modularização

14. Vários níveis de chamadas
a subprogramas

15. Exemplo de subprograma
em Português Estruturado
programa ExercicioA
inicio
execute VerificarDivisao()
fim
subPrograma VerificarDivisao()
var
numero : inteiro
contador : inteiro
resto2 : inteiro
resto3 : inteiro
inicio
para contador de 1 até 4 passo 1 faça
escreva “Digite numero:”
leia numero
resto2  numero mod 2
resto3  numero mod 3
se (resto2 = 0) .e. (resto3 = 0) então
escreva “Numero”, numero, “são divisiveis por 2 e por 3”
fim_se
fim_para
fim

16. Exemplo de subprograma
em linguagem C
#include <stdio.h>
//Declaracao dos procedimentos
void verificarDivisao();
void main()
{
//chamando a 1a vez a funcao
verificarDivisao();
//chando outra vez a mesma função
verificarDivisao();
}

17. Exemplo de subprograma
em linguagem C
void verificarDivisao()
{
int numero, contador, resto2, resto3;
for (contador=1; contador<=4; contador++)
{
printf("nDigite numero: ");
scanf("%d", &numero);
resto2 = numero % 2;
resto3 = numero % 3;
if ( (resto2 == 0) && (resto3 == 0) )
{
printf("nNumero: %d e divisivel por 2 e por 3!", numero);
}
else
{
printf("nNumero: %d NAO e divisivel por 2 e por 3 ao mesmo tempo!", numero);
}
}
}

18. Parâmetros
• Você é os valores que com subprograma
necessita receber para poder realizar sua
tarefa, ou os valores reproduz que devem ser
visíveis externamente após concluída sua
execução, devem ser sempre armazenados em
parâmetros.
• Parâmetros são espaços de armazenamento
que permitem a comunicação do
subprograma com o mundo externo;

19. Parâmetros
• Um subprograma que não utiliza parâmetros e
não utiliza informação do mundo exterior para
seu acionamento, produzir a sempre o mesmo
resultado, não importa onde seja chamado.

20. Parâmetro Formais e Reais
• Todos os elementos utilizados em um
subprograma devem ser nele declarados. As
declarações de parâmetros, além de nomeá-los
para uso interno no subprograma, define seu
tipo.
• Os parâmetros que aparecem na declaração dos
subprogramas são chamados de parâmetros
formais, porque durante a execução, na chamada
dos subprogramas, são substituídos por variáveis
ou valores do mesmo tipo, muitas vezes com
nomes totalmente diferentes;

21. Parâmetro Fomais e Reais
• O parâmetro formal não provoca a reserva de
espaço em memória. Ele simplesmente indica
que, ao ser chamado o subprograma, deve ser
fornecido um valor com seu tipo para a sua
execução;
• Os parâmetros utilizados na chamada de um
subprograma, chamados de parâmetros reais,
substituem os formais durante a execução;

22. Exemplo de parâmetro Fomais
e Reais em Pseudocódigo
programa ExercicioA
var
numero : inteiro
contador : inteiro
inicio
para contador de 1 até 4 passo 1 faça
escreva “Digite numero:”
leia numero
execute VerificarDivisao(numero)
fim_para
fim
subPrograma VerificarDivisao(pNum : inteiro)
var
resto2 : inteiro
resto3 : inteiro
inicio
resto2  pNum mod 2
resto3  pNum mod 3
se (resto2 = 0) .e. (resto3 = 0) então
escreva “Numero”, pNum, “são divisiveis por 2 e por 3”
senão
escreva “Numero”, pNum, “NÃO são divisiveis por 2 e por 3!”
fim_se
fim
PARÂMETRO FORMAL
PARÂMETRO REAL

23. Exemplo de parâmetro Fomais
e Reais em Linguagem C
PARÂMETRO REAL
#include <stdio.h>
//Declaracao dos procedimentos
void verificarDivisao(int pNum);
void main()
{
int numero, contador;
for (contador=1; contador<=4; contador++)
{
printf("nDigite numero: ");
scanf("%d", &numero);
verificarDivisao(numero);
}
}

24. Exemplo de parâmetro Fomais
e Reais em Linguagem C
PARÂMETRO FORMAL
void verificarDivisao(int pNum)
{
int resto2, resto3;
resto2 = pNum % 2;
resto3 = pNum % 3;
if ( (resto2 == 0) && (resto3 == 0) )
{
printf("nNumero: %d e divisivel por 2 e por 3!", pNum);
}
else
{
printf("nNumero: %d NAO e divisivel por 2 e por 3 ao mesmo tempo!", pNum);
}
}

25. Parâmetro Fomais e Reais
• Os parâmetros reais devem sempre concordar
em quantidade e tipo com os respectivos
parâmetros formais, na ordem em que eles foram
definidos;
• Podem ser fornecidos como parâmetros reais
nomes de variáveis, valores literais ou resultados
de expressões;
• As variáveis utilizadas como parâmetros reais
devem ter sido declaradas no programa que
chama o subprograma;

26. Parâmetros de Entrada e Saída
• A utilização dê um subprograma só é efetiva se
for claramente definida a tarefa que será
executada e qual sua interação que o acionou.
para que isso seja possível, é importante que
toda interação seja feita somente através de
parâmetros, identificando quais são os
parâmetros de entrada (que recebem variáveis o
valores para executar a tarefa) e quais são os
parâmetros de saída (que devolvem os valores
calculados ao programa que acionou o
subprograma).

27. Parâmetros por valor ou por
referência
• Com a passagem de valores a subprogramas
pode acontecer por valor ou por referência;
• A passagem por valor indica que somente o
valor que interessa ao subprograma.
• Se esse valor for passado por meio do nome
de uma variável, somente o valor da variável é
transferido para o parâmetro;

28. Parâmetros por valor ou por
referência
• Uma cópia do conteúdo da variável é carregada
em uma variável auxiliar, que será utilizada
durante a execução do subprograma;
• Dessa forma, qualquer modificação com novo
valor da variável auxiliar não se refletirá na
variável utilizada como parâmetro real;
• A passagem de valores para parâmetros definidos
por valor pode ser feita ainda por meio de um
valor literal e do resultado de uma expressão;

29. Parâmetros por valor ou por
referência
• Na execução da chamada há um subprograma, os
parâmetros passados por valor também são
incluídos na pilha de execução, preservando seus
valores para a continuação posterior da
execução;
• Na passagem de um parâmetro por referência, o
endereço físico dá variável utilizada como
parâmetro real é passada ao subprograma, sendo
esta variável utilizada durante a execução;

30. Parâmetros por valor ou por
referência
• Na passagem de um parâmetro por
referência, o endereço físico dá variável
utilizada como parâmetro real é passada ao
subprograma, sendo esta variável utilizada
durante a execução;

31. Parâmetros por valor
End.
Memória
Variavel Valor
ABC001 numero 5
ABC002 pNum 5
ABC003
...
var
numero : inteiro
inicio
numero  5
MostrarValor(numero)
fim
subprograma MostrarValor(pNum: inteiro)
inicio
escreva(pNum)
fim

32. Parâmetros por referência
End.
Memória
Variavel Valor
ABC001 numero 5
ABC002
ABC003
...
var
numero : inteiro
inicio
numero  5
MostrarValor(numero)
fim
subprograma MostrarValor(ref pNum: inteiro)
inicio
escreva(pNum)
fim

33. Parâmetros por valor ou por
referência
• Alterações no valor do parâmetro são feitas
diretamente nessa variável. Na chamada de
um subprograma, os parâmetros definidos por
referência recebem nomes de variáveis
existentes no programa o principal;
• É importante observar que, na execução de
uma chamada ao subprograma, os parâmetros
por referência não sofrem empilhamento, já
que não são locais aos subprogramas;

34. Declarações locais e globais
• Dentro de um subprograma, podem ser feitas
declarações de constantes, tipos e variáveis. as
declarações feitas internamente aos
subprogramas são declarações locais ao
subprograma, e só são visíveis dentro do
subprograma;
• As áreas de memória associadas as variáveis
locais são alocadas no momento em que o
subprograma é acionado eles são liberadas ao
final de sua execução, quando deixam de existir;

35. Declarações locais e globais
• Todo esse processo de criação e destruição de
variáveis locais ocorre novamente a cada nova
chamada ao subprograma;
• No fim da execução do subprograma, a
variável auxiliar (local) é liberada e não está
mais disponível;

36. Declarações locais e globais
• Tipos, constantes e variáveis declarados em
um programa, visíveis aos subprogramas que
estiverem nele declarados, são consideradas
declarações globais ao programa;
• Embora elementos globais posssam ser
utilizados dentro de subprogramas, essa
prática não é recomendável, pois dificulta o
entendimento e a depuração dos códigos;

37. Declarações locais e globais
LOCAIS GLOBAIS
Declarações internamente aos
subprogramas que as acessam
Declaradas externamente ao
subprogramas que as acessam
Só são reconhecidas e só podem ser
referenciadas nos subprogramas em que
são declaradas
São reconhecidas e podem ser
referenciadas até mesmo em
subprogramas em que não foram
declaradas
Existem apenas enquanto os
subprogramas em que foram declaradas
estiverem em execução
Sua existência independe dos
subprogramas que as acessam. Existem
antes, durante e após a ativação deles
Internamente a um subprograma, quando
têm o mesmo nome que uma global,
bloqueiam o acesso à global.

38. Escopo de identificadores
• A possibilidade de fazer declarações em
diferentes pontos de um programa (no
programa principal e em subprogramas)
requer que seja claramente identificado o
escopo de cada identificador. Por escopo,
entende-se a área de validade de um
determinado identificador;

39. Escopo de identificadores
• O escopo de um identificador é definido pela
localização de sua declaração. Declarações
feitas no programa principal valem em todo o
programa, inclusive, por vezes, nos
subprogramas que o compôem.
• Declarações feitas dentro de um subprograma
valem somente dentro desse subprograma.

40. Escopo de identificadores

41. Escopo de identificadores
#include <stdio.h>
//Declaracao dos procedimentos
void SubPrograma01();
int numeroGlobal;
void main()
{
int i, numero;
for (i=0; i<5; i++)
{
printf("nnDigite numero: ");
scanf("%d", &numero);
printf("nNumero digitado foi %d: ", numero);
}
numeroGlobal = 100;
printf("nNumero Global: %d", numeroGlobal);
SubPrograma01();
}
Variáveis Globais
Variáveis Locais

42. Escopo de identificadores
void SubPrograma01()
{
int i, numero;
for (i=5; i<10; i++)
{
printf("nnDigite numero: ");
scanf("%d", &numero);
printf("nNumero digitado foi %d: ", numero);
}
numeroGlobal = 200;
printf("nNumero Global: %d", numeroGlobal);
}
Variáveis Locais

43. Tipos de subprogramas
• Dois tipos de subprogramas podem ser
utilizados, diferenciados pela forma como são
acionados e o modo como devolvem seus
resultados: procedimentos e funções

44. Procedimentos
• Um procedimento é um subprograma que
executa uma determinada tarefa com ou sem
a utilização de parâmetros;
• Na lista de parâmetros formais, os parâmetros
por referencia devem ser identificados pela
sigla ref antes do seu nome;

45. Procedimentos
#include <stdio.h>
//Declaracao das procedures
void SomaNumeros(int valor1, int valor2);
void main()
{
int val1, val2, resultado;
val1 = 10;
val2 = 5;
SomaNumeros(val1, val2);
}
void SomaNumeros(int pValor1, int pValor2)
{
int total;
total = pValor1 + pValor2;
printf("nValor da Soma: %d", total);
}
Declaração sem
tipo de retorno
Não há return
chamada da procedure
não necessita de
variável para
armazenar valor

46. Funções
• Uma função é um subprograma que devolve
um valor, resultante de um cálculo ou da
execução de uma determinada tarefa, ao
programa que o chamou por meio de seu
nome;
• Uma função tem sempre associado a ela um
tipo, que é o tipo do valor que ela devolve
(valor de retorno);

47. Funções
• Em algum lugar do corpo da função, o valor
calculado pela função deve ser atribuído ao
seu nome, para ser devolvido ao programa
que a chamou;
• A chamada é feita escrevendo o seu nome,
com os parâmetros reais, no ponto do código
onde se deseja utilizar, e essa chamada é
atribuída geralmente a uma variável do
mesmo tipo que a função retorna;

48. Funções
#include <stdio.h>
//Declaracao das funcoes
int SomaNumeros(int valor1, int valor2);
void main()
{
int val1, val2, resultado;
val1 = 10;
val2 = 5;
resultado = SomaNumeros(val1, val2);
printf("nValor da Soma: %d", resultado);
}
int SomaNumeros(int pValor1, int pValor2)
{
int total;
total = pValor1 + pValor2;
return total;
}
Tipo de retorno
Retorno compatível com o
tipo da função
Chamada da função
variável que recebe
o retorno da função