7 - Modularização

Prévia do material em texto

Algoritmos
Prof. Hilton Cardoso Marins Junior
hiltonmarins@gmail.com
MODULARIZAÇÃO
Modularização
A modularização consiste num método para facilitar a construção de 
grandes programas, através de sua divisão em pequenos programas
conhecidos como módulos, rotinas, sub-rotinas ou sub-programas. 
Um dos objetivos do programador é dividir o programa em módulos de 
menor complexidade, eliminando o inconveniente dos programas se 
tornarem extremamente grandes e complexos, em aplicações de maior
porte.
O programador ao projetar um programa deverá levar em conta que os
módulos são criados de acordo com a sua função. Os módulos deverão ter
funções específicas e independentes (em termos funcionais).
Funções
Na linguagem C implementamos os módulos de programa através das 
funções. O programador ao projetar um programa deve procurar separar
blocos de comandos de acordo com sua função. Chamamos estes blocos de 
funções.
Uma função é um trecho de programa que possui cabeçalho, variáveis e 
comandos próprios e que pode ser executado por um programa ou outra
função.
Quando uma função é referenciada, o controle do fluxo de execução é 
automaticamente transferido para o princípio dela. As instruções são então
executadas. Após o término delas, o controle é automaticamente devolvido
à instrução imediatamente a seguir à chamada da função.
Invocando (Chamando) Uma Função
Todo programa em C é composto de funções. A execução é iniciada pela
função main().
Para executar uma função, ela deve ser invocada no corpo de uma outra
função, exceto a função main(), que é executada ao iniciar o programa.
O esquema abaixo mostra como é fluxo de execução ao invocarmos uma
função.
funcão-1(){
...
funcão-2();
...
}
funçao-2(){
...
}
Exemplo: chamando um função
void apresentacao(void);
int edivisivel( int a, int b);
main(){
int n1,n2;
apresentacao();
printf("\nInforme um numero: ");
scanf("%d", &n1);
printf("\nInforme um numero: ");
scanf("%d", &n2);
if ( edivisivel(n1,n2)){
printf("%d e divisivel por %d", n1, n2);
}else{
printf("%d NAO e divisivel por %d", n1, n2);
}
}
Protótipo das 
Funções
Continua…
Exemplo
void apresentacao(void){
system("cls");
printf("\n*************************************");
printf("\nPROGRAMA QUE EXPLICA O USO DE FUNCOES");
printf("\n\nIF SUDESTE MINAS GERAIS");
printf("\nProf. Hilton Cardoso Marins Junior");
printf("\n*************************************");
}
int edivisivel( int a, int b){
if ((a%b) == 0 ){
return 1;
}else{
return 0;
}
}
Implementação
das Funções
Argumentos de uma Função
São utilizados para transmitir informações para a função.
Se uma função usa argumentos, ela deve declarar variáveis que aceitem os valores
dos argumentos. Estas variáveis são chamadas de parâmetros formais. Os
parâmetros formais se comportam como quaisquer outras variáveis locais dentro
da função.
Uma função pode receber qualquer número de argumentos, inclusive nenhum. No 
caso de uma função sem argumentos pode-se escrevê-la de duas formas: deixando
a lista de argumentos vazia (mantendo-se entretanto os parênteses) ou colocando o 
tipo void entre parênteses.
int triplo(int r){
return 3*r;
}
void mostra(){ //ou void mostra(void)
printf(“Ola!!!!!!”);
}
Parâmetros
formais
Retorno de uma Função
É o valor que uma função retorna para a função que a chamou. O 
tipo de retorno é fornecido no cabeçalho da função antes de seu
nome.
int triplo(int r){
return 3*r;
}
O comando return faz com seja retornado o valor especificado e faz
com com a função termine. Se uma funcao não retorna nada, seu tipo
de retorno deve ser definido como void. 
void mostra(){
printf(“Ola!!!!!!”);
}
Retorno de uma Função
O comando return pode ser utilizado numa função com tipo de 
retorno void. Neste caso, o comando nao deve retornar nenhum
valor: return void.
O comando return pode ser utilizado também para indicar a saída
imediata da função, basta colocarmos o comando return sozinho. 
Se o tipo de retorno da função não é explicitamente declarado, o 
compilador C atribui automaticamente o tipo padrão, que é int.
Exemplo: retorno de uma função
float calculaMedia (float ,float ) ;
int main ( ) {
float a , b , m;
printf ("\nDigite o primeiro numero: " ) ;
scanf ("%f", &a ) ;
printf ("\nDigite o segundo numero: " ) ;
scanf ("%f", &b ) ;
m = calculaMedia (a, b) ;
printf("\nMedia entre %.2f e %.2f é %.2f\n",a,b,m);
}
float calculaMedia (float argA , float argB) {
float mediaCalculada ;
mediaCalculada = ( argA + argB ) / 2 ;
return mediaCalculada ;
}
Exemplo: recebendo um vetor como parâmetro
void imprimeMatriz (float argMatriz [4][4]);
int main(){
float matriz [4] [4] ;
int i , j ;
printf("\nDigite os elementos da matriz\n" ) ;
for (i = 0 ; i < 4 ; i++ ){
for (j = 0 ; j < 4 ; j++ ){
scanf ( "%f" ,&matriz [ i ] [ j ] ) ;
}
}
imprimeMatriz (matriz) ;
}
void imprimeMatriz (float argMatriz [4] [4]){
int i , j ;
printf("\nImpressao da matriz\n" ) ;
for (i = 0 ; i < 4 ; i++ ){
for (j = 0 ; j < 4 ; j++ ){
printf("%.1f\t" ,argMatriz [i][j]);
}
printf("\n");
}
}
Passagem de Parâmetros por Valor
Copia o valor de um argumento no parâmetro formal da função. 
Assim alterações no parâmetro formal da função não tem nenhum
efeito nos argumentos usados na chamada da função
int quadrado(int x);
main(){
int t=10;
printf("%d %d", quadrado(t), t);
getch();
}
int quadrado(int x){
x = x * x;
return x;
}
Obs.: Veremos passagem de parâmetros por referência após
aprendermos sobre ponteiros.
Locais de Declaração de Variáveis (Escopo)
Existem 3 lugares em um programa em C onde as variáveis podem ser declaradas:
Fora de todas as funções, inclusive da função main(). A variável assim
declarada é chamada de variável global e pode ser usada em qualquer
parte do programa. Uma variável global é criada (alocada na memória) 
quando o programa inicia e é destruída (liberada da memória) quando o 
programa é finalizado.
Dentro de uma função. A variável assim declarada é chamada de variável
local e só pode ser usada dentro desta função. Uma variável local é 
criada quando a função é invocada e destruída quando a função é 
finalizada.
Na lista de parâmetros formais de uma função, para receber os
argumentos que são passados para a função. Uma variável declarada
como parâmetro formal de uma função é criada quando a função é 
invocada e destruída quando a função é finalizada. Possui
comportamento idêntico da variável local.
1
2
3
Escopo de uma Variável
O escopo de uma variável é a região do programa que ela pode ser 
referenciada. Essa região tem como início a linha que declara a variável e 
como fim as chaves que finalizam o bloco.
void f (){
int t
scanf(“%d”,&t);
if (t ==1){
char s[80];
printf(“entre com o nome: “);
gets(s);
...
}
...
}
Região do programa em
que podemos referenciar
a variável t
Região do programa em
que podemos referenciar
a variável s
A Forma Geral de Um Programa em C
declarações das variáveis globais
declarações dos protótipos das funções
tipo-devolvido main (lista-de-parâmetros){
sequência-de-comandos;
}
tipo-devolvido f1 (lista-de-parâmetros){
sequência-de-comandos;
}
tipo-devolvido f2 (lista-de-parâmetros){
sequência-de-comandos;
}
...
tipo-devolvido fn (lista-de-parâmetros){
sequência-de-comandos;
}
Obs.: f1()até fn() representam as funções definidas pelo usuário.
Argumentos da Função Main()
Para passar informações para um programa ao executá-lo utilizamos
argumento de linha de comando.
Argumento de linha de comando é a informação que segue o nome do 
programa na linha de comando do sistema operacional.
Para executar o programa abaixo digitamos no prompt do sistema
operacional: testeJose seguindo de enter.
main(int argc, char *argv[]){
if (argc !=2){
printf("Voce esqueceu de informar o nome.\n");
getch();
exit(1);
}
printf("Ola %s",argv[1]);
getch();
}
Argumentos da Função Main()
O primeiro parâmetro (argc) é um inteiro que contém o número de argumentos
da linha de comandos que foram passados. Ele é sempre pelo menos 1, porque o 
nome do programa será o primeiro argumento.
O segundo parâmetro (argv) é um ponteiro para um vetor de ponteiros para char. 
Cada elemento deste vetor aponta para um argumento da linha de comando. 
argv[0] aponta para a primeira string, que é sempre o nome do programa, argv[1] 
aponta para a segunda string, e assim por adiante.
main(int argc, char *argv[]){
if (argc !=2){
printf("Voce esqueceu de informar o nome.\n");
getch();
exit(1);
}
printf("Ola %s",argv[1]);
getch();
}