Ameliara Freire Ameliara.fjn@gmail.com Programação I Ameliara Freire Ameliara.fjn@gmail.com

Modularização

Dividir para Conquistar

Modularização Situação Parte 1 Problema Parte 2 Parte 3 Parte 4

Modularização Solução Parte 1 Parte 1 Problema Parte 2 Parte 2 Parte 3

Modularização::Subprograma Solução Parte 1 Subprograma 1 Programa Subprograma 2 Parte 2 Parte 3 Subprograma 3 Parte 4 Subprograma 4

Modularização::Subprograma 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.

Modularização::Bloco 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 }. Declarações de variáveis Comandos

Modularização::Subprograma 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: Declarações de variáveis Comandos

Modularização::Subprograma Existem dois tipos de subprograma: Procedimentos Executam tarefas Funções Calculam Valores

Modularização::Subprograma 01/04/2017 Modularização::Subprograma 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().

Modularização::Subprograma 01/04/2017 Modularização::Subprograma Funções e Procedimentos Exemplo: Procedimento que não recebe parâmetros e não retorna valor. Implementacao do procedimento #include <stdio.h> void desenha(); main() { printf(”Usando procedimento."); desenha( ); } Assinatura ou protótipo do procedimento void desenha() { int i; for (i = 0; i <= 10; i++) printf("--\n"); }

Procedimento

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

Procedimento Exemplo: void linha(){ int i; Exibir na tela uma linha com 20 asteriscos. void linha(){ int i; for (i = 1; i <= 20; i++) printf(‘*’); printf(‘\n’); }

Procedimento 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 procedimento void 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); }

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 void main(){ int i; linha(); puts(“Numeros entre 1 e 5”); for(i = 1; i <= 5; i++) printf(“%d\n”, i); } void linha(){ int i; for (i = 1; i <= 20; i++) printf(‘*’); printf(‘\n’); }

Função

Função Sintaxe: Exemplo: 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ção float 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.

Escopo de variáveis

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

Escopo de variáveis Variáveis Globais: Variáveis Locais: 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.

Escopo de variáveis Exemplo de Escopo em uma Função:

Parâmetros

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 Reais 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 Formais Parâmetros Reais

Passagem de parâmetro por valor

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.

Passagem de parâmetro por valor Exemplo:

Introdução a Ponteiro

Memória Organizacao da memória (variável inteira) int x; (0xFF02)x 01/04/2017 Memória Organizacao da memória (variável inteira) int x; (0xFF02)x 0000000

Memória Organizacao da memória (variável inteira) int x; x = 5; 01/04/2017 Memória Organizacao da memória (variável inteira) int x; x = 5; (0xFF02)x 5

Ponteiros (apontadores) 01/04/2017 Ponteiros (apontadores) 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: x 0x3287AB 0x3287AB 4 x

Ponteiros (apontadores) 01/04/2017 Ponteiros (apontadores) Sintaxe: Variáveis que são ponteiros são representadas da seguinte forma: tipo *nome_variavel; Exemplo: int *x; x NULL

Ponteiros (apontadores) 01/04/2017 Ponteiros (apontadores) Sintaxe: Variáveis que são ponteiros são representadas da seguinte forma: tipo *nome_variavel; Exemplo: int *x; int y = 5; x NULL (0xAD036)y 5

Ponteiros (apontadores) 01/04/2017 Ponteiros (apontadores) Sintaxe: Variáveis que são ponteiros são representadas da seguinte forma: tipo *nome_variavel; Exemplo: int *x; int y = 5; x = &y; x 0xAD036 (0xAD036)y 5

Trabalhando com ponteiros 01/04/2017 Trabalhando com ponteiros 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; int *x; (0x3847CD)x NULL if (x != NULL) { ... } int *x; printf(“Endereco da variavel x: %d”,&x); printf(“Endereco guardado em x: %d”,x);

Trabalhando com ponteiros 01/04/2017 Trabalhando com ponteiros Atribuição de ponteiros. Só podemos jogar dentro do ponteiro um endereço; *x – representa o conteúdo final do ponteiro; int *x; int y = 35; x = &y; (0x3847CD)x 0x32496 (0x32496)y 35 int *x; printf(“Conteudo final de x: %d”,*x); *x = 28;

Trabalhando com ponteiros 01/04/2017 Trabalhando com ponteiros 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 via y: %d\n",y);

Passagem de parâmetro por referência

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:

Passagem de parâmetro por referência

Passagem de parâmetro por referência

Ponteiros com registros 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.

#include <stdio. h> #include <conio #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"); 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; case 2: A[qa].mens = 130; break; case 3: A[qa].mens = 160; break; case 4: A[qa].mens = 170; 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: "); gets(A[qa].ender.Bairro); printf("\n Cidade : "); 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(); }