O documento discute modularização através do refinamento sucessivo de algoritmos em módulos menores como funções. Explica que a modularização melhora a manutenibilidade, legibilidade e reusabilidade do código. Fornece um exemplo de como dividir um algoritmo que lê três números e imprime o menor em funções separadas para cada etapa.

1. Modularização
Prof. Sérgio Souza Costa
Site:https://sites.google.com/site/profsergiocosta/
Email: prof.sergio.costa@gmail.com

2. Programação estruturada
A crise do software no ínicio da década de
1970 levou a programação estruturada.
Além do conceito de que todo programa pode
ser escrito usando sequencia, seleção e
repetição.
Surgiu o conceito de refinamento sucessivo (ou
top-down) - modularização.

3. Refinamento sucessivo
● Técnica utilizada para tentar minimizar a
complexidade da resolução de um problema
● “Dividir para Conquistar”
○ Divida o problema e subproblemas menores.
■ Se a resolução de um subproblema ainda for
complexa
● Divida o subproblema em subproblemas menores
ainda, e assim, sucessivamente ...

4. Refinamento sucessivo
Ex. Algoritmo que lê três valores inteiros, determina e
imprime o menor deles.
int main(void){
// declarar as variáveis
// Ler os números
// Determinar o menor deles
// Escrever o menor número
return 0;
}

5. Refinamento sucessivo
Ex. Algoritmo que lê três valores inteiros, determina e
imprime o menor deles.
int main(void){
// declarar as variáveis
// Ler os números
// Determinar o menor deles
// Escrever o menor número
return 0;
}
scanf(“%d %d %d”, &a, &b, &c);
Ref. ler_numeros

6. Refinamento sucessivo
Ex. Algoritmo que lê três valores inteiros, determina e
imprime o menor deles.
int main(void){
// declarar as variáveis
// Ler os números
// Determinar o menor deles
// Escrever o menor número
return 0;
}
scanf(“%d %d %d”, &a, &b, &c);
Ref. ler_numeros
if ((a < b) && (a < c)) {
menor = a;
} else {
...
}
Ref. menor_deles

7. Refinamento sucessivo
Ex. Algoritmo que lê três valores inteiros, determina e
imprime o menor deles.
int main(void){
// declarar as variáveis
// Ler os números
// Determinar o menor deles
// Escrever o menor número
return 0;
}
scanf(“%d %d %d”, &a, &b, &c);
Ref. ler_numeros
if ((a < b) && (a < c)) {
menor = a;
} else {
...
}
Ref. menor_deles
printf(“%dn”, menor);
Ref. escrever_menor

8. Refinamento sucessivo
Ex. Algoritmo que lê três valores inteiros, determina e
imprime o menor deles.
#include <stdio.h>
int main(void){
int a, b, c, menor;
scanf(“%d %d %d”, &a, &b, &c);
if ((a < b) && (a < c)) {
menor = a;
} else {
if (b < c)
menor = b;
else
menor = c;
}
printf(“%dn”, menor);
return 0;
}
Declarar as variáveis
Ler os números
Determinar o menor deles
Escrever o menor número

9. Refinamento sucessivo
Ex. Algoritmo que lê três valores inteiros, determina e
imprime o menor deles.
#include <stdio.h>
int main(void){
int a, b, c, menor;
scanf(“%d %d %d”, &a, &b, &c);
if ((a < b) && (a < c)) {
menor = a;
} else {
if (b < c)
menor = b;
else
menor = c;
}
printf(“%dn”, menor);
return 0;
}
Pode ser
modularizado
através de uma
função. Podendo
ser utilizado em
outras partes do
programa.

10. Refinamento sucessivo
Ex. Algoritmo que lê três valores inteiros, determina e
imprime o menor deles.
#include <stdio.h>
int menor(int x, int y, int z){
int m;
if ((x < y) && (x < z)) {
m = x;
} else {
if (y < z) menor = y;
else m = z;
}
return m;
}
int main(void){
int a, b, c, menor;
scanf("%d %d %d", &a, &b, &c);
printf("%dn", menor(a, b, c));
return 0;
Uma função para
determinar o menor
valor entre 3
inteiros

11. Refinamento -> Modularização

12. Refinamento -> Modularização
+Manutenibilidade

13. Refinamento -> Modularização
+Manutenibilidade
+Legibilidade

14. Refinamento -> Modularização
+Manutenibilidade
+Legibilidade
+Reusabilidade

15. Refinamento -> Modularização
+Manutenibilidade
+Legibilidade
+Reusabilidade
Confiabilidade

16. Modularização
Transformar refinamento sucessivo em
módulos
● Módulos
○ formas agrupadas de conjuntos de
instruções (encapsulada em funções e ou
tipos de dados) responsáveis por executar
uma ação bem definida, podendo ou não
repetir-se em diferentes pontos de um
programa.

17. ● Um conjunto de instruções (utilizadas para cumprir uma
tarefa particular) agrupadas num módulo com um nome para
referenciá-lo, esse módulo pode ou não retornar um valor
(numérico, caractere, estruturado, lógico, etc) como
resultado.
○ Quando não retorna valor é usualmente referido como
procedimento.
● Vantagens
○ dividir a tarefa original em pequenas tarefas que simplificam e
organizam o programa como um todo.
○ reduzir o tamanho do programa. Qualquer sequência de
instruções que apareça no programa mais de uma vez é
candidata a ser uma função.
Funções

18. Funções
Um programa C é dividido em pequenas funções:
– Bons programas são compostos por diversas
pequenas
funções.
– Como o próprio nome diz, uma função representa
uma
funcionalidade.
– A vantagem de se ter o código modularizado em
funções é que o código fica mais fácil de entender, de
manter, de atualizar e de
reusar.

19. Funções
“Funções são os blocos de construção de C e
o local onde toda a atividade do programa
ocorre.” Herberth Schildt (C Completo e Total)
“Uma função é uma unidade de código de
programa autônoma desenvolvida para cumprir
uma determinada tarefa em particular”
(MIZRAHI, 1990).

20. Funções - Sintaxe
Toda função em C é definida assim:
tipo_retorno identificador (lista de parâmetros){
corpo da função (sequencia de comandos);
}
escopo

21. Funções - Sintaxe
Toda função em C é definida assim:
tipo_retorno identificador (lista de parâmetros){
corpo da função (sequencia de comandos);
}
escopo

22. Tipos de retorno
● O tipo de uma função é definido pelo tipo de valor que
ela retorna por meio do comando return.
● Os tipos de funções em C são os mesmos tipos de
variáveis, exceto quando a função não retorna nada
(void).
○ int, char, float, double e void
○ tipos criados pelo usuario

23. Funções - Sintaxe
Toda função em C é definida assim:
tipo_retorno identificador (lista de parâmetros){
corpo da função (sequencia de comandos);
}
escopo

24. Identificador de uma função
A estrutura de uma função em C é semelhante à de uma
função main().
A diferença é que main() possui um nome especial
reservado.
O programador pode dar o nome que desejar para a
função que irá definir, desde que o nome:
Seja diferente de palavras reservadas (int, char, float,
break, switch, while ...) da Linguagem.
Não contenha caracteres especiais (#$%@*&-+”: =;,.)
Não seja igual aos nomes de outras funções previamente
declaradas ou de outras bibliotecas (main, printf, scanf, getchar,
strcmp, system, etc);

25. Funções - Sintaxe
Toda função em C é definida assim:
tipo_retorno identificador (lista de parâmetros){
corpo da função (sequencia de comandos);
}
escopo

26. Parâmetros
● As informações transmitidas para uma função são
chamadas parâmetros.
● Os parâmetros podem ser utilizados livremente no
corpo da função.
○ Agem como variáveis locais da função
p = cubo(3);
q = media(2,6);

27. Funções - Sintaxe
Toda função em C é definida assim:
tipo_retorno identificador (lista de parâmetros){
corpo da função (sequencia de comandos);
}
escopo

28. Sequência de comandos
Como já vimos na função main, podemos ter
declarações de variáveis, comandos de
atribuição, entrada, saída, seleção, iteração e
chamadas a outras funções.

29. Exemplo
#include <stdio.h>
int celsius (int fahr) // definição da função
{
int r;
r = (fahr - 32) * 5.0/9; // Corpo da função
return r;
}
int main(void){
int c, f;
printf("Digite a temperatura Fahrenheit: ");
scanf(“%d”, &f);
c = celsius(f); // chamada à função
printf(“%d F é igual a %d Cn”, f, c);
return 0;
}
escopo
Parâmetro(s)tipo
retorno

30. Comando return
● O comando return termina a execução da função e
retorna o controle para a instrução seguinte do código
de chamada.
● Se após a palavra return houver uma expressão, o
valor da expressão é retornado à função que
chama. Por exemplo, no programa anterior as
funções celsius() e min() retornam valores para
main().
● Sintaxe:
return;
return <expressão>;
return (<expressão>);

31. Comando return
● Um return desacompanhado de
expressão somente termina a função
void funcao_nada(void) {
printf(“Nada”);
return;
}
● Quando não há retorno a função termina
quando encontra a chave }
Neste caso, o uso do
comando return não é
obrigatório.

32. Execução de funções
● Um programa pode conter uma ou mais
funções, das quais uma delas deve ser
main().
○ A execução do programa sempre começa em main()
e, quando o controle do programa encontra uma
instrução que inclui o nome de uma função, a
função é chamada.#include <stdio.h>
int main(void){
printf(“Pressione uma tecla”);
system(“cls”);
return 0;
}

33. Execução de funções
#include <stdio.h>
int celsius (int fahr) // definição da função
{
int r;
r = (fahr - 32) * 5.0/9; // Corpo da função
return r;
}
int main(void){
int c, f;
printf("Digite a temperatura Fahrenheit: ");
scanf(“%d”, &f);
c = celsius(f); // chamada à função
printf(“%d F é igual a %d Cn”, f, c);
return 0;
}

34. Execução de funções
#include <stdio.h>
int celsius (int fahr) // definição da função
{
int r;
r = (fahr - 32) * 5.0/9; // Corpo da função
return r;
}
int main(void){
int c, f;
printf("Digite a temperatura Fahrenheit: ");
scanf(“%d”, &f);
c = celsius(f); // chamada à função
printf(“%d F é igual a %d Cn”, f, c);
return 0;
}

35. Execução de funções
#include <stdio.h>
int celsius (int fahr) // definição da função
{
int r;
r = (fahr - 32) * 5.0/9; // Corpo da função
return r;
}
int main(void){
int c, f;
printf("Digite a temperatura Fahrenheit: ");
scanf(“%d”, &f);
c = celsius(f); // chamada à função
printf(“%d F é igual a %d Cn”, f, c);
return 0;
}

36. Execução de funções
#include <stdio.h>
int celsius (int fahr) // definição da função
{
int r;
r = (fahr - 32) * 5.0/9; // Corpo da função
return r;
}
int main(void){
int c, f;
printf("Digite a temperatura Fahrenheit: ");
scanf(“%d”, &f);
c = celsius(f); // chamada à função
printf(“%d F é igual a %d Cn”, f, c);
return 0;
}

37. Execução de funções
#include <stdio.h>
int celsius (int fahr) // definição da função
{
int r;
r = (fahr - 32) * 5.0/9; // Corpo da função
return r;
}
int main(void){
int c, f;
printf("Digite a temperatura Fahrenheit: ");
scanf(“%d”, &f);
c = celsius(f); // chamada à função
printf(“%d F é igual a %d Cn”, f, c);
return 0;
}
o valor da variavel f da função main
será copiado para o parametro fahr
da função celsius

38. Execução de funções
#include <stdio.h>
int celsius (int fahr) // definição da função
{
int r;
r = (fahr - 32) * 5.0/9; // Corpo da função
return r;
}
int main(void){
int c, f;
printf("Digite a temperatura Fahrenheit: ");
scanf(“%d”, &f);
c = celsius(f); // chamada à função
printf(“%d F é igual a %d Cn”, f, c);
return 0;
}

39. Execução de funções
#include <stdio.h>
int celsius (int fahr) // definição da função
{
int r;
r = (fahr - 32) * 5.0/9; // Corpo da função
return r;
}
int main(void){
int c, f;
printf("Digite a temperatura Fahrenheit: ");
scanf(“%d”, &f);
c = celsius(f); // chamada à função
printf(“%d F é igual a %d Cn”, f, c);
return 0;
}

40. Execução de funções
#include <stdio.h>
int celsius (int fahr) // definição da função
{
int r;
r = (fahr - 32) * 5.0/9; // Corpo da função
return r;
}
int main(void){
int c, f;
printf("Digite a temperatura Fahrenheit: ");
scanf(“%d”, &f);
c = celsius(f); // chamada à função
printf(“%d F é igual a %d Cn”, f, c);
return 0;
}

41. Execução de funções
#include <stdio.h>
int celsius (int fahr) // definição da função
{
int r;
r = (fahr - 32) * 5.0/9; // Corpo da função
return r;
}
int main(void){
int c, f;
printf("Digite a temperatura Fahrenheit: ");
scanf(“%d”, &f);
c = celsius(f); // chamada à função
printf(“%d F é igual a %d Cn”, f, c);
return 0;
}

42. Execução de funções
#include <stdio.h>
int celsius (int fahr) // definição da função
{
int r;
r = (fahr - 32) * 5.0/9; // Corpo da função
return r;
}
int main(void){
int c, f;
printf("Digite a temperatura Fahrenheit: ");
scanf(“%d”, &f);
c = celsius(f); // chamada à função
printf(“%d F é igual a %d Cn”, f, c);
return 0;
}

43. Passagem de parâmetros (valor)
int dobro (int x ) {
return 2 * x;
}
int main () {
int a, b;
a = 10;
b = dobro (a);
}
O valor da variável "a" é
copiado (por valor) para o
parâmatro "x" da função
dobro

44. Exercícios
Exercícios na página do curso.