PRG122804 2019 1 AULA03

Objetivos

O aluno deverá ser capaz de

• Construir fluxogramas usando estruturas de repetição.
• Compreender o aninhamento de estruturas de controle de fluxo.
• Dividir problemas em subproblemas e utilizar subrotinas para organizar a solução.

Estruturas de repetição

No exemplo de controle de acesso da aula passada já construímos uma estrutura de repetição (um loop infinito). Vamos elaborar um pouco mais estas estruturas de repetição.

Uma das grandes vantagens de um sistema computacional é a capacidade de repetir um conjunto de instruções possivelmente sobre dados diferentes, a uma velocidade muito grande.

PROBLEMA

Calcular a somatório de N valores a serem fornecidos pelo teclado.

$S=\sum _{i=0}^{N-1}a_{i}=a_{0}+a_{1}+..+a_{N-1}$

DADOS DE ENTRADA:

N /* número de valores */,

a_i /* valor de um dos N números a serem inseridos */

DADOS DE SAÌDA = S /* somatório */

NOTA: Observe que a estrutura de repetição utilizada é caracterizada por um teste (decisão) de uma expressão que deverá resultar em verdadeiro enquanto houver número a ser lido (dentro da quantidade N de números), um contador de itens lidos "i" e um bloco de repetição terminado em um arco que conduz o fluxo de execução ao início da decisão.

EXERCÍCIO: Construir um fluxograma para ler N números inteiros e um número inteiro de de referência REF. O programa deve contar a quantidade de números maior que REF

Quebrando um problema em subproblemas: SUBPROGRAMAS

PROBLEMA: Aprimorar o exemplo do controle de acesso para que, no caso de 3 tentativas de acesso seguidas, com senha errada, o sistema seja bloqueado.

• DADOS DE ENTRADA: SENHA /* variável que armazena a senha entrada pelo usuário ou administrador */
• DADOS DE SAÍDA: mensagem de abertura da porta / usuário bloqueado*/
• VARIÁVEIS INTERMEDIÁRIAS: CONT_ACESSO /* valor inicial zero - incrementada a cada senha inválida */

Note que a variável CONT_ACESSO é iniciada com zero e incrementada a cada erro no fornecimento da senha. A atribuição CONT_ACESSO = CONT_+ACESSO + 1 deve ser interpretada da forma: acesse o valor de CONT_ACESSO e some 1 a este valor. Coloque o resultado novamente em CONT_ACESSO (o conteúdo anterior é sobrescrito!)

Neste procedimento pode ser observado que:

• Começa a aparecer uma certa complexidade no fluxograma;
• Além disto, não ficou uma abordagem muito interessante, pois se for o administrador que erra a senha, ele pode bloquear o usuário;
• Não existe forma de desbloquear a senha (zerar o contador), a não ser mudando a senha.

Em síntese, existem subproblemas adicionais a serem resolvidos. Como podemos resolvê-los sem deixar um fluxograma complexo?

Usaremos a caixa "processos pré-definidos" para chamar as funções que resolvem determinado subproblema.

Inicialmente, vamos construir três subprogramas:

• Iniciar_Sistema(): inicia variáveis do sistema, colocando o sistema em um estado inicial conhecido;
• Tratar_Admin(): é o código que trata a funcionalidade associada ao administrador;
• Tratar_User(): é a funcionalidade que trata o usuário (procedimento de abrir porta, bloquear etc).

Note que foi usada uma variável auxiliar AUX que permite ajustar o valor de número de acessos a ser mostrado no display. Note também que na caixa DISPLAY foi usado uma string a ser impressa e a variável AUX cujo conteúdo deve ser impresso. Ambos separados por vírgula.

ANINHAMENTO DE DECISÕES

A função Tratar_User() se utiliza de aninhamento de decisões. Em um primeiro momento é testado se a senha confere com a senha do :usuário. SE ela conferir ENTÃO é testado se o contador de bloqueios está dentro do aceitável.

Parâmetros e Retorno de Valores em Subprogramas

Para tornar ainda mais interessante o uso de subprogramas, vamos ver o conceito de passagem de parâmetros e retorno de valores.

Quando chamamos (invocamos) um subprograma podemos passar valores (dados de entrada) para este subprograma.

Estes valores são passados através de variáveis especiais que chamamos de parâmetros.

Parâmetros podem ser passados por valor e por referência. Por valor é quando os dados a serem passados na invocação

do subprograma são copiados para uma variável do subprograma.

Os parâmetros são passados por referência quando o que é passado para o subprograma é simplesmente o endereço da variável

repassada na invocação do subprograma.

Não existe uma forma explícita de definir os parâmetros em um fluxograma. Deve-se realizar um comentário antes ou ao lado do mesmo especificando o tipo e como será tratado o parâmetro.

EXEMPLO: Seja elaborar um fluxograma correspondente a uma subprograma que deve calcular o fatorial de um número inteiro passado como parâmetro. O subprograma deve retornar o valor calculado.

A função fatorial é definida por:

$n!=\prod _{k=1}^{n}k\qquad \forall n\in \mathbb {N}$

Neste fluxograma, o subprograma denominado CalcFatorial recebe um valor no parâmetro N (implicitamente inteiro) e retorna o valor calculado do fatorial.

O fluxograma principal invoca duas vezes o subprograma. O retorno é armazenado nas variáveis NUM1 e NUM3.

Quando um subprograma retorna um valor, ele é chamado de função. Para manter coerência com o C chamaremos

qualquer subprograma de função (independente de retornar valor).

EXERCÍCIO 1: Implementar uma função (subprograma), usando fluxograma, para computar o valor da PG, dados como parâmetros s e q.

EXERCÍCIO 2: Implementar uma função (subprograma), usando fluxograma, que recebe dois números inteiros como parâmetro. A função retorna 1 se os números forem iguais, 0 se o primeiro número maior que o segundo e -1 se o segundo for maior que o primeiro.

Exercícios

EXERCÍCIO 1: Modificar o sistema de controle de acesso para incluir a inserção de nome de usuário (USERID) e senha (SENHA). Prever a existência de dois usuários (USERID_1, USERID_2, SENHA_1, SENHA_2). O admin poderá ser identificado pelo nome ADMIN. Prever bloqueio por usuário (duas variáveis contadores). Sugestão: criar funcões separadas para tratamento de cada usuário. Em breve veremos como podemos contornar esta duplicação através da parametrização de funções/subprogramas.

EXERCÍCIO 2: Escrever um fluxograma que leia como dados de entrada dois números inteiros positivos: "s" e "q". O programa deve computar os dez primeiros números da PG (progressão geométrica), onde "s" é o número inicial e "q" a razão da progressão.

Obs: Para PG tem-se:

$a_{1}=s\,$

$a_{n}=q\times a_{n-1}$ ou

$a_{n}=a_{1}.q^{n-1}\,\!$

EXERCÍCIO 3: Implementar um fluxograma que permita computar a somatória dos N primeiros termos de uma PG, cujos valores de "s" e "q" são também fornecidos como dados de entrada.

EXERCÍCIO 4: Implementar um fluxograma que permita mostrar na tela os 100 primeiros números primos.

Fluxograma

Programa em C
#include <stdio.h> int main() { int i=1,conta=0,conta_div=0,n; while (conta<100) { n=1; conta_div=0; while (n<i) { if ((i%n)==0) { conta_div++; } n++; } if (conta_div<2){ printf("\nconta: %d, num: %d",conta+1,i); conta++; } i++; } return 0; }

---