Lógica de programação

Prof. Jonas de Araújo Luz Junior

http://jonasluz.com.br
jonasluz@gmail.com

Variáveis Indexadas e Registros

 Motivação
● Algumas vezes, pode-se querer que uma única
variável armazene mais de um valor.
– As variáveis indexadas armazenam mais de um valor
do mesmo tipo e, por isto, são também chamadas
variáveis compostas homogêneas.
– Os registros são tipos definidos pelo programador que
mantém uma estrutura de dados com sub-variáveis,
que podem ser de tipos diferentes. Por isto, são
chamadas também de variáveis compostas
heterogêneas.
 Variáveis Indexadas
● Diversos problemas computacionais requerem a
declaração de um grande número de variáveis
com a mesma semântica.
– Exemplos:
● obter a média de 100 números, exibindo-os no final.
● ordenar 500 nomes ou valores.
● Podem-se declarar variáveis indexadas, ou seja,
com o mesmo identificador (portanto, declaradas
somente uma vez), mas com que armazenam
diferentes valores em diferentes índices.
 Variáveis Indexadas
● Representam conjuntos ordenados de valores
homogêneos, ou seja, do mesmo tipo.
– Em linguagens fracamente tipadas, os valores podem
ser de tipos diferentes.
● Classificam-se, quanto ao número de dimensões:
– Unidimensionais: apenas uma dimensão de índice.
Conhecidas também por arranjos, vetores ou arrays.
– Bidimensionais: possuem duas dimensões de índice.
Também conhecidas como matrizes.
– N-dimensionais: algumas linguagens permitem a
declaração de variáveis com n dimensões.
 Vetores
● São as variáveis indexadas unidimensionais.
● Sintaxe:
<nome_var>: vetor[ <li>..<lf> ] de <tipo>
● Representação na memória do computador:
... ... Ao lado:
● VS é uma variável
74 80
simples de valor 10
75 -10 81 ocupando a posição
VS 10 76 56 82 76 da memória.
VI ● VI é uma variável

77 1 83 indexada de 4
78 0 84 posições; ocupa 4
79 85 posições na memória.

... ...
MEMÓRIA MEMÓRIA
 Vetores
● Notas importantes:
– A indexação do vetor com n elementos não precisa ser
de 1 a n, podendo ser, por exemplo, de 0 a n - 1 ou de
5 a n + 4.
● Algumas linguagens de programação permitem que se
indique apenas o tamanho do vetor e não seus índices
limites. Deve-se portanto ter cuidado pra se verificar se a
linguagem inicia a indexação pelo 0 ou pelo 1.
– Tentar acessar um elemento com índice fora dos
limites do vetor constitui um erro de programação.
 Vetores
● Notas importantes:
– O índice de um vetor é inteiro e, portanto, pode-se
usar uma variável inteira para referenciá-lo.
● Exemplo: estrutura para vasculhar um vetor:
// i varia do limite inicial (li) até o limite final (lf) 
para i <­ li até lf faca
valor <­ variavelIndexada[i]
// faça algo com o valor 
fimpara
// Algumas linguagens possuem uma estrutura própria: 
foreach
foreach (valor in variavelIndexada) { 
// faça algo com valor 
}
 Vetores
● Exemplo: média aritmética de 10 números.
algoritmo "MediaValoresVetor"
var
   valores: vetor [1..10] de real
   i: inteiro
   ac: real
inicio
   para i <­ 1 ate 10 faca
      escreva ("Informe o ", i, "º valor: ")
      leia (valores[i])
      ac <­ ac + valores[i]
   fimpara
.
.
.
 Vetores
● Exemplo: média aritmética de 10 números.
.
.
.   
escreval("­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­")
   escreval("O cálculo da média é determinado por: ")
   escreva ("( ")
   para i <­ 1 ate 10 faca
      escreva (valores[i])
      se i < 10 entao
         escreva (" +")
      fimse
   fimpara
   escreva (" ) / 10 = ", (ac / 10))
fimalgoritmo
 Vetores
● Exemplo: pesquisa em vetor
algoritmo "ProcuraNome"
var
   nomes: vetor[1..5] de caracter
   procura: caracter
   i, resposta: inteiro
inicio
   para i <­ 1 ate 5 faca
      escreva("Escreva o nome do aluno nº ", i, ": ")
      leia (nomes[i])
   fimpara
   escreval 
("­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­")
   escreva ("Escreva parte do nome de quem procura: ")
   leia (procura)
...
 Vetores
● Exemplo: pesquisa em vetor
...
   i <­ 1
   repita
      se pos(procura, nomes[i]) <> 0 entao
         resposta <­ i
      fimse
      i <­ i + 1
   ate (i > 5) ou (resposta <> 0)
   se resposta = 0 entao
      escreval ("Nome não encontrado!")
   senao
      escreval ("Nome encontrado: ", nomes[resposta])
   fimse
fimalgoritmo
 Matrizes
● São as variáveis indexadas bidimensionais.
● Sintaxe:
<nome_var>: vetor[ <li1>..<lf1>, 
<li2>..<lf2> ] de <tipo>
● Representação em matriz de uma variável V:
Índices 1 2 3 4 5
1 V[1,1] V[1,2] V[1,3] V[1,4] V[1,5]
2 V[2,1] V[2,2] V[2,3] V[2,4] V[2,5]
3 V[3,1] V[3,2] V[3,3] V[3,4] V[3,5]
4 V[4,1] V[4,2] V[4,3] V[4,4] V[4,5]
 Matrizes
...
● Representação na 86
memória do -10 87 M[1,1]
56 88 M[1,2]
computador 1 89 M[2,1]
– O espaço total ocupado 0 90 M[2,2]
21 91 M[3,1]
da matriz de tamanho M : [1..5, 1..2]
...
49 91 M[3,2]
M por N (M linhas e N MEMÓRIA
-10 92 M[4,1]
colunas) é igual a 56 93 M[4,2]
M×N 1 94 M[5,1]
0 95 M[5,2]
96
...
 Matrizes
● Exemplo: Grade de notas
algoritmo "GradeNotas"

var
  aluno : vetor[1..100] de caracter
  nota  : vetor[1..100, 1..3] de real
  nome  : caracter
  a, n  : inteiro
inicio

  // faz a leitura de até 100 alunos.
  a <­ 1
  enquanto (a <= 100) e (nome <> "­") faca
    escreval ("Nome do aluno (sinal ­ encerra a leitura): ")
    leia (nome)
    se nome <> "­" entao
      aluno[a] <­ nome
      // faz a leitura das notas
      para n <­ 1 ate 2 faca
        repita
          escreva ("Informe a ", n, "ª nota (de 1 a 10): ")
          leia (nota[a, n])
        ate (nota [a, n] >= 0) e (nota [a, n] <= 10)
      fimpara
      // calcula a média
      nota[a, 3] <­ (nota[a, 1] + nota[a, 2]) / 2

    fimse
    a <­ a + 1
  fimenquanto
  // Ajusta a para marcar total de alunos informados.
  se a > 100 entao
    a <­ 100
  senao
    a <­ a ­ 2
  fimse
  
  // exibe grade
  limpatela
  escreval ("GRADE DE NOTAS")
  escreval ("­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­")
  escreval (" ALUNO                        |N­1|N­2|MEDIA")
  escreval ("­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­")

  para n <­ 1 ate a faca
    escreva (aluno[n], " | ", nota[n,1], " | ", nota[n,2])
    escreval (" | ", nota[n,3])
  fimpara

  escreval ("­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­")

fimalgoritmo
 Vetores multidimensionais
● Como visto, uma matriz é contruída como um
vetor bidimensional.
● Vetores podem ter n dimensões, sendo: n∈ℕ , n≥1
● São duas construções possíveis:
<nome_var> : 
vetor [<li1>..<lf1>, <li2>..<lf2>, ..., <lin>..<lfn>] de <tipo>

<nome_var> : 
vetor [<li1>..<lf1>] de vetor [<li2>..<lf2>] ... de 
vetor[<lin>..<lfn>] de tipo
 Vetores dinâmicos
● Um vetor dinâmico não possui um tamanho fixo;
seu tamanho pode ser definido e alterado após
sua declaração, por uma função específica.
var 
<nome_var>  : array of <tipo>;
i, num_elem : integer; 
begin
setLength(<nome_var>, <tamanho>); 
// retorna o número de elementos do vetor:
num_elem := length(<nome_var>); 
// vasculha o vetor:
for i := low(<nome_var>) to high(<nome_var>) do ... 
 Vetores associativos ou
tabelas de dispersão
● Um vetor associativo, tabela ou mapa de
dispersão, ou ainda, tabela ou mapa de
espalhamento – em inglês, hash map ou
hash table – associa os valores a chaves únicas.
– Exemplo: em PHP, todos os arrays são, na verdade,
mapas de dispersão.
$mapaAluno = array(
"numero"  => "", 
"nome"  => "", 
"notas" => array(0, 0),
"media" => 0
);
foreach – estrutura para varrer vetores
● Tradicionalmente, um vetor é varrido por uma
estrutura para (for, na maioria das linguagens).
// Em Portugol: (abstração: limini e limfim dão os limites do vetor)
para i <­ limini(<var_vetor>) ate limfim(<var_vetor>) faca ...
// Em Pascal: (funciona no Free Pascal – freepascal.org)
for i := low(<var_vetor>) to high(<var_vetor>) do ... 
// Em Java: 
for (int i = 0; i < <var_vetor>.length; i++) { ... }

● As linguagens mais modernas apresentam já uma

estrutura específica que evita o uso de uma
variável de controle para o índice.
foreach – estrutura para varrer vetores
● As linguagens mais modernas já apresentam uma
estrutura específica que evita o uso de uma
variável de controle para o índice: o foreach.
// Em Portugol, ficaria: (estrutura não existe na literatura)
paracada <var_item> em <var_vetor> faca ...
// onde <var_item> deve ser do mesmo tipo dos elementos de <var_vetor>
// Em Pascal, a estrutura não existe.
// Em Java: 
for (<tipo> <var_item> : <var_vetor>) { ... }
// Em PHP: 
foreach (<var_vetor> as <var_item>) { ... } // ou:
foreach (<var_vetor> as <var_item_chave> => <var_item_valor>) { ... }
 Registro
● Às vezes, há a necessidade de se integrar uma
estrutura de dados.
– Exemplos:
● A ficha de um aluno (matrícula, nome, notas, disciplinas).
● Os dados de um formulário a ser preenchido no programa.
● Uma estrutura de dados que integra dados de
tipos diferentes e pode ser usada para atender à
necessidade anterior é o registro.
 Registro
● O registro é a uma estrutura de dados que agrupa,
em um tipo definido pelo programador, sub-
variáveis de diferentes tipos relacionadas entre si.
– As sub-variáveis do registro podem ser de quaisquer
tipos nativos, vetores, ou mesmo outro tipo registro.
● A estrutura de dados comumente usada por
sistemas gerenciadores de banco de dados
relacionais (SGBDR) é uma espécie de registro.
 Registro
● Sintaxe:
– Declaração do tipo:
tipo <tipo_registro> = registro
  <declaração de tipos e variáveis>
...
fim tipo
– Declaração de variável:
var <variavel> : <tipo_registro>
– Uso:
<variavel>.<nome_subvariavel> ← <valor>
 Registro
● Exemplo em Pascal: Controle de notas.
program ControleNotas;

// Tipo definido para o registro (a ficha) do aluno.
type recAluno = record
  matricula : string;
  nome      : string;
  sexo      : char;
  nota      : array[1..2] of single;
  media     : single;
end;

// Tipo definido para o registro (a ficha) da turma.
// Note o uso de um vetor de alunos para os integrantes da turma.
type recTurma = record
  codigo : string;
  nome   : string;
  aluno  : array[1..50] of recAluno;
end;
 Registro
● Exemplo em Pascal: Controle de notas (continuação)
var
  i, j      : integer;
  continuar : string;
  turma     : recTurma;

begin

  writeln( 'CONTROLE DE NOTAS' );
  writeln( '­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­');

  // LEITURA DOS DADOS DA TURMA:
  writeln( 'Informe os dados da turma:' );
  write( 'Codigo: ');
  // o acesso aa subvariavel e´ feito pela sintaxe de ponto:
  readln( turma.codigo);
  write( 'Nome: ');
  readln( turma.nome);
 Registro
● Exemplo em Pascal: Controle de notas (continuação)
  // LEITURA DOS DADOS DOS ALUNOS:
  i := 1; continuar := '';
  while (i <= 50) and (continuar = '') do begin
    writeln( 'Informe os dados do aluno nº ', i, '...' );
    write( 'Matricula: ' );
    // note o acesso ao registro aninhado em outro por um vetor:
    readln(turma.aluno[i].matricula );
    write( 'Nome: ' );
    readln(turma.aluno[i].nome );
    repeat begin
      write( 'Sexo (M ou F): ' );
      readln(turma.aluno[i].sexo );
    end until (turma.aluno[i].sexo = 'M') or 
              (turma.aluno[i].sexo = 'F');
    for j := 1 to 2 do begin
      write( 'Nota ', j, ': ' );
      readln( turma.aluno[i].nota[j] );
    end;
 Registro
● Exemplo em Pascal: Controle de notas (continuação)
    // calcula a media deste aluno durante a leitura.
    turma.aluno[i].media :=
      ( turma.aluno[i].nota[1] + turma.aluno[i].nota[2] ) / 2;
    // Pergunta se continua a ler alunos.
    i := i + 1;
    writeln(
      'Digite algo seguido de [ENTER] para parar a leitura ',
      'ou apenas [ENTER] para ler os dados de outro aluno.'
    );
    readln( continuar );
  end;
  
  // EXIBIÇAO DA FICHA DE NOTAS:
  writeln( '­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­');
  writeln( ' TURMA: ', turma.codigo, ' ­ ', turma.nome );
  writeln( '­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­');
  writeln( ' ALUNO                    NOTA 1 ­ NOTA 2 ­ MEDIA ');
  writeln( '­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­');
 Registro
● Exemplo em Pascal: Controle de notas (continuação)
  for i := 1 to i ­ 1 do begin
    write( Copy(turma.aluno[i].nome, 1, 40) );
    if ( length(turma.aluno[i].nome) < 40 ) then
      // nao requer begin ou end porque executa apenas uma 
instruçao.
      write( 
        StringOfChar(' ', 40 – length(turma.aluno[i].nome)) 
      );
    write( 
      turma.aluno[i].nota[1], ' ­ ', turma.aluno[i].nota[2] 
    );
    writeln( turma.aluno[i].media );
  end;
  writeln( '­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­');

end.
 Bibliografia
(1) Wikipedia. Em: http://en.wikipedia.org
(2) Wikipédia. Em: http://pt.wikipedia.org
(3) SOUZA, Marco Antônio Furlan de; et. al.
Algoritmo e Lógica de Programação.
São Paulo: Thomson Learning, 2005.
(4) FORBELLONE, André Luiz Villar; et.al.
Lógica de Programação.
São Paulo: Pearson Prentice-Hall, 2005.