ameliara freire [email protected]. dividir para conquistar

Programação IAmeliara Freire

[email protected]

Modularização

Dividir para Conquistar

Situação

Modularização

Parte 1

Parte 2

Parte 3

Parte 4

Problema

Solução

Modularização

Parte 1

Parte 2

Parte 3

Parte 4

Parte 1Parte 2

Parte 3

Parte 4

Problema

Solução

Modularização::Subprograma

Parte 1

Parte 2

Parte 3

Parte 4

Subprograma 1Subprograma 2

Subprograma 3

Subprograma 4

Programa

A solução do problema original é implementada através da composição dos subprogramas.

Subprogramas podem ser vistos como blocos de construção com os quais montamos um programa.

Esta técnica de construção de programas é chamada de MODULARIZAÇÃO.


Um bloco consiste em um conjunto de declarações e um conjunto de comandos delimitados por indicadores de início e fim de bloco.

Em C, os delimitadores de bloco são { e }.

Modularização::Bloco

Comandos

Declarações de variáveis

Um subprograma é um bloco de programa constituído por um conjunto de declarações e por um conjunto de comandos e identificado por um nome.

Exemplo:


Comandos

Declarações de variáveis

Existem dois tipos de subprograma:

◦ Procedimentos Executam tarefas

◦ Funções Calculam Valores


Funções e Procedimentos◦ Toda função ou procedimento deve ser pelo

menos declarada antes da função principal main(). Declara a função/procedimento antes da main() e a

implementa depois. Implementa a função/procedimento diretamente

antes da main().


Funções e Procedimentos◦ Exemplo: Procedimento que não recebe

parâmetros e não retorna valor.


#include <stdio.h>

void desenha();

main(){ printf(”Usando procedimento."); desenha( );}

void desenha(){ int i; for (i = 0; i <= 10; i++) printf("--\n");}

Assinatura ou protótipo

do procediment

o

Implementacao do

procedimento

Procedimento

Sintaxe:void nome_procedimento(lista_parâmetros){ declarações_de_variáveis_do_procedimento; lista_de_comandos_do_procedimento;}

Procedimento

Exemplo:◦ Exibir na tela uma linha com 20 asteriscos.

Procedimento

void linha(){ int i; for (i = 1; i <= 20; i++) printf(‘*’); printf(‘\n’); }

A definição de um procedimento associa um nome a um bloco de declarações e comandos.

Os comandos que compõem o bloco do procedimento têm a “missão” de executar uma determinada tarefa para o programa.

Procedimento

Exemplo de chamada a um procedimentovoid main(){ int i; linha(); /* escreve uma linha de asteriscos */ puts(“Numeros entre 1 e 5”); linha(); /* escreve outra linha de asteriscos */ for(i = 1; i <= 5; i++) printf(“%d\n”, i); linha(); /* escreve outra linha de asteriscos */}

Procedimento

Chamada (Execução) de um Procedimento

◦ Uma referência a um nome de procedimento dentro de um programa provoca a execução do bloco de comandos do procedimento.

◦ Ao término da execução do procedimento, a execução do programa continua a partir do ponto onde este foi chamado.

Procedimento

Chamada (Execução) de um Procedimento

Procedimento

void linha(){ int i; for (i = 1; i <= 20; i++) printf(‘*’); printf(‘\n’); }

void main(){ int i; linha(); puts(“Numeros entre 1 e 5”); linha(); for(i = 1; i <= 5; i++) printf(“%d\n”, i); linha();}

Função

Sintaxe:tipo_retorno nome_função (lista_parâmetros){ declarações_de_variáveis_da_função; lista_de_comandos_da_função;}

Exemplo:◦ Calcular o valor da soma de dois números reais.

float soma(float a, float b) { float aux; aux = a + b; return aux; }

Função

Chamada a uma funçãofloat soma(float a, float b) { float aux; aux = a + b; return aux; }void main () { float x,y,z; printf(“Digite X:”); scanf (“%f”, &x); printf(“Digite Y:”); scanf (“%f”, &y); z = soma(x,y); printf(“Soma: %f”,z);}

Função

Definição:

◦ A definição de uma função associa um nome a um bloco de declarações e comandos.

◦ Os comandos que compõem o bloco da função têm a “missão” de calcular um valor que deve ser informado pela função.

Função

Chamada (execução) de Função:

◦ Uma referência a um nome de função dentro de um programa provoca a execução do bloco de comandos da função.

◦ Ao término da execução da função, a execução do programa continua a partir do ponto onde a função foi chamada.

Função

Escopo de variáveis

Definição de Escopo◦ O escopo de uma variável é a parte do código do

programa onde a variável é visível e, portanto, pode ser utilizada.

◦ Com relação ao escopo, as variáveis se dividem em: Globais Locais


Variáveis Globais:◦ São as variáveis declaradas fora dos

procedimentos e das funções;◦ São visíveis e podem ser utilizadas em toda a

extensão do programa; Variáveis Locais:

◦ São as variáveis declaradas dentro dos procedimentos e das funções;

◦ São visíveis e podem ser utilizadas apenas dentro do subprograma que as declarou.


Exemplo de Escopo em uma Função:


Parâmetros

Parâmetros são utilizados em computação para possibilitar a construção de subprogramas genéricos.

Parâmetros

Parâmetros Formais◦ Parâmetros formais são as variáveis declaradas

no cabeçalho do subprograma.

Parâmetros Reais◦ Parâmetros reais são as variáveis passadas no

instante da chamada do subprograma.

Parâmetros

Exemplo:

Parâmetros

Parâmetros Formais

Parâmetros Reais

Passagem de parâmetro por valor

No instante da chamada do subprograma, o parâmetro formal recebe uma cópia do valor do parâmetro real correspondente.

Alterações feitas nos parâmetros formais não refletem nos parâmetros reais correspondentes.

Caracteriza-se por ser um mecanismo de entrada de dados para o subprograma.


Exemplo:


Introdução a Ponteiro

Organizacao da memória (variável inteira)

Memória

int x; 0000000

(0xFF02)x

Organizacao da memória (variável inteira)

Memória

int x;x = 5;

5

(0xFF02)x

Ponteiros (ou apontadores) são variáveis que, ao invés de guardar um dado (valor), guardam um endereço de memória, associada a outra variável;

Dessa forma, ponteiros fazem referência a uma outra variável;

Exemplo:

Abstração:

Ponteiros (apontadores)

0x3287ABx

40x3287AB

x

Sintaxe: ◦ Variáveis que são ponteiros são representadas da

seguinte forma: tipo *nome_variavel;◦ Exemplo:


NULLxint *x;




NULLxint *x;int y = 5;

5(0xAD036)y




0xAD036xint *x;int y = 5;x = &y; 5(0xAD036)y

Toda declaração de ponteiros, inicia o ponteiro com o valor default NULL;

É sempre bom testar se o ponteiro na é NULL antes de acessá-lo;

x – representa o endereço armazenado no ponteiro;

Trabalhando com ponteiros

NULL(0x3847CD)xint *x;

int *x;printf(“Endereco da variavel x: %d”,&x);printf(“Endereco guardado em x: %d”,x);

if (x != NULL) { ...}

Atribuição de ponteiros.◦ Só podemos jogar dentro do ponteiro um

endereço;

*x – representa o conteúdo final do ponteiro;


0x32496(0x3847CD)xint *x;int y = 35;x = &y;

int *x;printf(“Conteudo final de x: %d”,*x);*x = 28;printf(“Conteudo final de x: %d”,*x);

35(0x32496)y

O que acontece no seguinte programa?


int y = 5;int *x;x = &y;printf("Valor armazenado na variavel y: %d\n", y);printf("Endereco de y: %d\n",&y);printf("Valor do conteudo do ponteiro x: %d\n",*x);printf("Valor do endereco armazenado no ponteiro x: %d\n", x);printf("Valor do endereco de x: %d\n",&x); printf("Alterando o valor armazenado na variavel x\n");*x = *x + 1;printf("Novo valor do conteudo do ponteiro x: %d\n",*x);printf("Valor do endereco armazenado no ponteiro x: %d\n", x);printf("Valor via y: %d\n",y);

Passagem de parâmetro por

referência

Caracteriza-se por ser um mecanismo de comunicação bidirecional com o subprograma, ou seja, é um mecanismo de entrada e saída de dados.

Qualquer modificação feita em um parâmetro formal implica em alteração no parâmetro real correspondente.

Passagem de parâmetro por referência

Na passagem por referência utiliza-se um tipo de dados especial chamado ponteiro, que representa o endereço da variável passada por parâmetro. Representado pelo * após o tipo da variável e antes do seu nome.

Exemplo:


Crie um programa na linguagem C que define a estrutura de um carro, altere seus dados através de uma função (use passagem por referência e o operador ->) bem como use outra função para exibir os membros da struct.

Ponteiros com registros

#include <stdio.h>

#include <conio.h>

typedef struct

{

char modelo[30];

float potenciaMotor;

int anoFabricacao,

numPortas;

}CARRO;

void Exibe(CARRO car)

{

printf("\n\tExibindo carro\n");

printf("Modelo: %s\n", car.modelo);

printf("Motor: %.1f\n", car.potenciaMotor);

printf("Ano: %dn", car.anoFabricacao);

printf("%d portas\n", car.numPortas);

}

void Preenche(CARRO *car)

{

printf("Modelo do carro: ");

gets( car->modelo );

printf("Motor: ");

scanf("%f", &car->potenciaMotor);

printf("Ano: ");

scanf("%d", &car->anoFabricacao);

printf("Numero de portas: ");

scanf("%d", &car->numPortas);

}

main(void)

{

CARRO fusca;

Preenche(&fusca);

Exibe(fusca);

getche();

}

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

typedef struct {

char Rua[100], Bairro [20], Cidade [20];

int num, cep;

} tipo_endereco;

typedef struct { int mat, serie, irmao;

char nome[20];

float mens;

tipo_endereco ender;

} tipo_aluno;

void relatorio_geral(tipo_aluno v_alunos[20],int q )

{

int j;

printf("Colegio Legal\n");

printf("\n\nRelatorio Geral\n");

printf("\n________________________________");

printf("\nMat.\tNome\tSerie\tIrmao\tMens.\tRua\tBairro\tCidade\tNumero\tCep");

printf("\n________________________________");

for(j = 0; j < q; j++)

{

printf("\n %5d %-10s %5d %5d %5.2f %-10s %-10s %-10s %5d %5d ",

v_alunos[j].mat, v_alunos[j].nome, v_alunos[j].serie,

v_alunos[j].irmao, v_alunos[j].mens, v_alunos[j].ender.Rua,

v_alunos[j].ender.Bairro, v_alunos[j].ender.Cidade,

v_alunos[j].ender.num, v_alunos[j].ender.cep);

printf("\n_______________________________");

}

}

int preencher(tipo_aluno A[20])

{

int qa, i, resp;

qa =0;

do{

printf("Colegio Legal\n");

printf("\n\nCadastro de Alunos\n\n");

printf("\nMatricula.: ");

scanf("%d",&A[qa].mat);

printf("\nNome......: ");

fflush(stdin);

gets(A[qa].nome);

printf("\nSerie(1-4): ");

scanf("%d",&A[qa].serie);

printf("\nIrmao na escola(1-sim/0-nao):");

scanf("%d",&A[qa].irmao);

switch(A[qa].serie){

case 1: A[qa].mens = 110; break;




}

if (A[qa].irmao == 1)

A[qa].mens = A[qa].mens*0.8;

printf("\n digite o endereco: ");

printf("\n Rua : ");

fflush(stdin);

gets(A[qa].ender.Rua);

printf("\n Bairro: ");

fflush(stdin);

gets(A[qa].ender.Bairro);

printf("\n Cidade : ");

fflush(stdin);

gets(A[qa].ender.Cidade);

printf("\n numero: ");

;

scanf("%d",&A[qa].ender.num);

printf("\n cep: ");

scanf("%d",&A[qa].ender.cep);

qa++;

printf("\n\nDeseja cadastrar outro aluno(1-sim/0-nao)? ");

scanf("%d",&resp);

}while ((resp == 1) && (qa <20));

return qa;

}

main(){

int qa;

tipo_aluno alunos[20];

qa=preencher(alunos);

relatorio_geral(alunos,qa);

printf("\nTecle enter para sair...");

getche();

}

ameliara freire [email protected]. dividir para conquistar

Documents