Armazenamento de dados.
Suponha que você desenvolveu um jogo de computador chamado "User Hostile" no qual os jogadores competem contra interface do computador. 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. Introdução.
Para facilitar o trabalho com grandes quantidades de dados, um grupo de células recebe um nome. 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.
Há três coisas que você precisa aprender ao trabalhar com arrays:
x alocar memória do tamanho necessário para o array;
x gravar dados na célula desejada;
x ler dados de uma célula.
Crie uma matriz.
Ao criar uma matriz, o espaço é alocado na memória (um certo número de células).
1) Arrays podem ser criados simplesmente enumerando elementos:
int[] nums = < code>new int[] { 1, 2, 3, 5 };
int significa que todos os objetos na matriz são inteiros. No lugar de int pode haver qualquer outro tipo de dado. Por exemplo,
string[] nomes = ["Vasya", "Peter", "Fedya"];
2) Não podemos especificar imediatamente os valores do array, mas simplesmente criar um array do tamanho que precisamos.
int[] nums = novo int[4];
3) Um array sempre "sabe" seu tamanho. O tamanho do array a pode ser encontrado assim:
a.Comprimento;
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:
int N = 10; // armazena o tamanho do array na variável N
int[] num = novo int[4]; // cria um array de tamanho N
Console.Write(nums.Length); // mostra o tamanho do array
O tamanho da matriz pode ser definido no teclado.
|
Referindo-se a um elemento de matriz.
A maior 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 determinado elemento da matriz.
Lembre-se: a numeração de matriz C# começa em zero.< br />
Exemplos de acesso ao array A:
int x = (A[3] + 5) * A[1] / / ler valores A[3] e A[1]
A[0] = x + 6 // escreve novo valor em A[0]
Vamos analisar o programa para trabalhar com elementos de matriz.
int i = 1;
int[] A = novo int[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];
Console.Write((A[2] + A[4]));
Como resultado da execução deste programa, o valor da soma dos elementos da matriz com índice 2 e com índice 4 aparecerá na tela, igual a 116. Como você pode ver no exemplo, podemos acessar qualquer elemento do array. E também calcule o número do elemento necessário 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 analisar um programa de exemplo.
int N = 5;
int[] A = novo int[N];
int x = 1;
A[x + 4] = A[x] + A[2 * (x + 1)]; // depois de substituir x em expressões e cálculos
// obtém a próxima linha A[5] = A[1] + A[4]
// A[5] tal elemento não existe
// erro - matriz fora dos limites
A matriz é declarada com 5 elementos, o que significa que os elementos serão numerados de 0 a 4. Vemos que o programa na 6ª linha refere-se a um elemento inexistente: A[5].
Acontece que o programa ultrapassou os limites do array.
Um array overrun é um acesso a um elemento em um índice que não existe no array.
Nesses casos, o programa geralmente falha com um erro de tempo de execução.
|
Ao trabalhar com arrays, você geralmente tem que trabalhar com todos os elementos do array de uma só vez.
Iterar sobre os elementos: examinamos todos os elementos do array e, se necessário, realizamos alguma operação com cada um deles.
Para isso, é mais comum usar um loop com uma variável, que muda de 0 para N-1, onde N é o número de elementos do array.
Em N vamos considerar o tamanho atual do array, ou seja,
N = A.Length;
...
for (int i = 0; i < N; i++)
{
// aqui trabalhamos com A[i]
}
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.
Ou seja, basta descrever o que precisa ser feito com um elemento do array A[i] e colocar essas ações dentro desse loop.
Vamos escrever um programa que preencha o array com os primeiros N 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 da matriz deve ser maior em 1 do que o índice do elemento.
O loop ficará assim
for (int i = 0; i < N; i++) { A[ i] = i + 1; }
|
Formas adicionais de trabalhar com elementos de matriz
Exceto para para , você também pode usar foreach - itera sobre todos os elementos do array, sem usar índices. Às vezes pode ser conveniente, por exemplo, exibir uma matriz na tela.
foreach(int i em A)
{
Console.Write(i + " ");
}
E é assim que você pode ler uma matriz, cujos elementos são escritos em uma linha e separados por um espaço, do teclado.
usando System.Linq; // você precisa escrever esta diretiva para usar funções relacionadas ao trabalho com arrays
...
string text = Console.ReadLine();
int[] array = text.Split(' ').Select(int.Parse).ToArray();
// Split() divide a string em objetos separados (neste caso, divisão de espaço)
// Select(int.Parse) converte cada objeto (string) em um int
// ToArray() escreve todos os objetos recebidos no array
|