Armazenamento de dados
Digamos que você desenvolveu um jogo de computador chamado "User Hostile" no qual os jogadores competem contra uma interface de computador intrincada e hostil. Agora você precisa escrever um programa que rastreie as vendas mensais deste jogo durante um período de cinco anos. Ou digamos que você precise inventariar as Cartas Colecionáveis do Herói Hacker.
Muito em breve você chegará à conclusão de que precisa de mais do que simples tipos básicos de dados para armazenar e processar informações.
Matrizes (listas). Introdução
Para facilitar o trabalho com uma grande quantidade de dados, um grupo de células recebe um nome comum. Esse grupo de células é chamado de array
Array – é um grupo de células de memória do mesmo tipo, localizadas lado a lado e com um nome comum. Cada célula do grupo tem um número único.
Ao trabalhar com arrays, você precisa aprender a resolver três tarefas:
x alocar memória do tamanho necessário para um array
x gravar dados na célula desejada
x ler dados da célula
Matrizes em Pascal
Tradicionalmente, Pascal usa arrays estáticos como
var a: array [1..10] de inteiro;
Os limites de uma matriz devem ser definidos por constantes e você não pode alterar o tamanho de uma matriz durante a operação do programa. Mas você pode criar um índice não apenas de um número inteiro, mas também, digamos, de um caractere ou tipo enumerado. Por exemplo, para contar a ocorrência de cada letra, você pode usar um array
var LettersCount: array ['a'..'z'] de inteiro;
e trabalhe com ele o quanto quiser:
Contagem de Letras['z'] := 1;
LettersCount['d'] := LettersCount['d'] + 1;
As desvantagens de tais arrays são conhecidas: se não se sabe com antecedência quantos elementos precisarão ser usados, então o tamanho máximo de memória é alocado para o array. Como resultado, na maioria dos casos, "estocamos para o futuro" e, às vezes, essa "reserva" acaba por não ser suficiente. É por isso que tais arrays são chamados estáticos: seu tamanho é estático e deve ser definido na fase de compilação do programa. No entanto, em Pascal existem arrays dinâmicos, cujo tamanho pode não apenas ser definido, mas também alterado no decorrer do programa. São essas matrizes e as vantagens de usá-las que serão discutidas mais adiante.
Criando uma matriz
Ao criar uma matriz, o espaço é alocado na memória (um certo número de células)
1) Matrizes podem ser criado simplesmente listando os elementos:
var a: array de inteiro;
SetLength(a, 3);
a[0] := 1;
a[1] := 2;
a[2] := 3;
2) As matrizes podem ser compostas por dados de qualquer tipo - números inteiros ou reais, cadeias de caracteres
var a: array de char;
SetLength(a, 3);
a[0] := 'a';
a[1] := 'b';
a[2] := 'c';
3) Uma matriz sempre "sabe" seu tamanho. A função length é usada para determinar o tamanho de uma matriz. Freqüentemente, o tamanho da matriz é armazenado em uma variável separada para que o programa possa ser facilmente alterado para funcionar com um tamanho de matriz diferente. Exemplo:
N:= 10; // na variável N armazenamos o tamanho do array
SetLength(a, N); // define array e tamanho N
writeln(comprimento(a)); //exibe o tamanho do array
O tamanho de uma matriz pode ser definido no teclado.
|
Referenciando um elemento de array
Grande parte da utilidade dos arrays vem do fato de que seus elementos podem ser acessados individualmente.
A maneira de fazer isso é usar um índice para numerar os elementos.
Índice é um valor que aponta para um elemento específico da matriz
LEMBRE-SE!
A NUMERAÇÃO DE ARRAYS EM PASCAL COMEÇA DO ZERO!
(Isso é obrigatório — você deve começar do zero. É especialmente importante lembrar disso)
Exemplos de acesso ao array A:
x := (A[3] + 5) * A[1] // lê os valores de A[3] e A[1]
A[0] := x + 6 // escreve novo valor em A[0]
Vamos analisar o programa para trabalhar com elementos de array.
var i: inteiro;
a: array de inteiros;
começar
i := 1;
definir comprimento(a, 5); //cria um array de 5 elementos
a[0] := 23; // para cada um dos 5 elementos do array (índices de 0 a 4)
a[1] := 12; // escreve um valor específico
a[2] := 7;
a[3] := 43;
a[4] := 51;
a[2] := a[i] + 2 * a[i - 1] + a[2 * i]; // altera o valor do elemento com índice 2 para o resultado da expressão
// porque i=1, então substituindo o valor da variável i na expressão obtemos
// próxima expressão a[2] := a[1] + 2*a[0] + a[2];
writeln(a[2] + a[4]);
fim.
Como resultado da execução neste programa aparecerá na tela o valor da soma dos elementos do array com índice 2 e com índice 4 igual a 116. Como você pode ver no exemplo, podemos acessar qualquer elemento da matriz . E também calcule o número necessário do elemento usando várias fórmulas (por exemplo, como no programa A[i-1] ou A[2*i], nesses casos, os índices dos elementos serão calculados e dependem do valor de i.)
Vamos ver um exemplo de programa
var a: array de inteiro;
começar
definir comprimento(a, 5);
a[5] := 5;
a[-1] := 0;
fim.
Porque a matriz é declarada com 5 elementos, então os elementos serão numerados de 0 a 4. Vemos que o programa na 6ª linha refere-se a um elemento inexistente а [5] e na 7ª linha ao também inexistente a[-1].
Acontece que o programa ultrapassou os limites do array
Array fora dos limites está acessando um elemento com um índice que não existe no array.
Nesses casos, o programa geralmente falha com erro de tempo de execução
|
Ao trabalhar com arrays, você normalmente tem que trabalhar com todos os elementos do array de uma vez.
Iterando pelos elementos: examinamos todos os elementos do array e, se necessário, realizamos alguma operação em cada um deles.
Para isso, o mais utilizado é um loop com uma variável, que varia de 0 a N-1, onde N é o número de elementos do array.
Em N vamos considerar o tamanho atual do array, ou seja
N := comprimento(A)
...
para i := 0 até n - 1 comece
// aqui trabalhamos com a[i]
fim;
...
No loop especificado, a variável i assumirá os valores 0, 1, 2, ..., N-1. Assim, a cada passo do loop, acessamos um elemento específico do array com o número i.
Assim, basta descrever o que precisa ser feito com um elemento do array a[i] e colocar essas ações dentro de tal ciclo.
Vamos escrever um programa que preencha o array com os primeiros N & nbsp; números naturais, ou seja, ao final do programa os elementos do array devem ficar iguais
a[0] = 1
a[1] = 2
a[2] = 3
...
a[N - 1] = N
É fácil ver o padrão: o valor de um elemento do array deve ser maior em 1 que o índice do elemento.
O loop ficará assim
para i := 1 até n - 1 faça
a[i] := i + 1;
Conclua a tarefa.
|