Arrays monodimensionais e multidimensionais no C#

Declarando o vetor

Para declarar um vetor, você informa o tipo dos elementos e a quantidade de posições:

// Vetor com 10 posições do tipo int
var singleDimensionalArray = new int[10];

Lembre que os arrays no C# começam na posição zero. Sendo assim, um array de 10 elementos fica com as posições 0, 1, 2 e assim por diante, até 8 e 9.

O C# é uma linguagem fortemente tipada. Isso significa que, uma vez definido o tipo do array, o compilador só aceita valores desse mesmo tipo.

Também vale saber que o C# preenche as posições não inicializadas com o valor padrão do tipo. Em um array de int, por exemplo, todas as posições começam com 0, enquanto em um array de string começam com null.

Inicializando o vetor

Você pode inicializar o array já na declaração, informando os valores entre chaves:

// Declaração e inicialização na mesma linha
var singleDimensionalArray = new int[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

Nesse caso, a quantidade de valores precisa bater com o tamanho informado. Caso contrário, o compilador acusa um erro.

Outra opção é atribuir o valor de cada posição depois da criação:

// A primeira posição (índice 0) recebe o valor 61
singleDimensionalArray[0] = 61;

O valor entre colchetes representa a posição do array que vai receber o valor. Ou seja, no exemplo acima a posição zero recebe 61, e ao ler a primeira posição do array teremos 61 como retorno.

Lendo itens do vetor

Ler o valor de um elemento é bem simples. Basta chamar o array e passar entre colchetes a posição desejada:

// Exibe o valor da primeira posição
Console.WriteLine($"{singleDimensionalArray[0]}");

Assim, o console exibe o valor guardado na posição indicada. Se você informar uma posição que não existe, como singleDimensionalArray[10] em um vetor de 10 elementos, o runtime lança uma IndexOutOfRangeException.

Percorrendo o vetor com for e foreach

Você pode usar tanto a instrução for quanto a instrução foreach para percorrer o array. Dessa forma, o código executa uma ação a cada nova posição visitada.

Primeiro, vamos atribuir valores a cada posição do array:

// Cada posição recebe o próprio número do índice
for (var index = 0; index < singleDimensionalArray.Length; index++)
    singleDimensionalArray[index] = index;

No exemplo acima, a propriedade Length devolve o total de elementos. Então, a posição zero recebe o valor 0, a posição um recebe o valor 1, e assim por diante.

Em seguida, percorremos o array e exibimos o valor guardado em cada posição:

// Leitura com for, usando o índice
for (var index = 0; index < singleDimensionalArray.Length; index++)
    Console.WriteLine(singleDimensionalArray[index]);

O foreach simplifica a leitura, porque entrega diretamente o valor de cada elemento:

// Leitura com foreach, usando o valor
foreach (var item in singleDimensionalArray)
    Console.WriteLine(item);

Repare que, dentro do foreach, a variável item já é o valor, e não a posição. Por isso, escrever singleDimensionalArray[item] é um erro comum, que só funciona por coincidência quando os valores são iguais aos índices.

Na dúvida, use for quando precisar da posição (para alterar o valor, por exemplo) e foreach quando só precisar ler os itens.

Métodos úteis da classe Array

Como todo array deriva de System.Array, os vetores ganham métodos estáticos prontos para tarefas comuns. Assim, você não precisa escrever à mão rotinas de ordenação ou de busca.

var scores = new int[] { 42, 7, 19, 88, 3 };

// Ordena os elementos em ordem crescente
Array.Sort(scores);

// Inverte a ordem dos elementos
Array.Reverse(scores);

// Procura a posição de um valor (retorna -1 se não encontrar)
var position = Array.IndexOf(scores, 19);

Console.WriteLine(string.Join(", ", scores)); // 88, 42, 19, 7, 3
Console.WriteLine(position);                  // 2

Atenção, porém, porque Array.Sort, Array.Reverse e Array.IndexOf trabalham apenas com vetores. Se você passar arrays multidimensionais para esses métodos, o runtime lança uma RankException.

Por isso, ao ordenar os dados de uma matriz, normalmente você copia uma linha para um vetor, ordena e devolve os valores. Esse limite ajuda a entender por que vetores e arrays multidimensionais têm usos diferentes no dia a dia.

Copiando um vetor com Clone

Quando precisar copiar um array, prefira o método Clone(). Isso acontece porque o operador = não copia os elementos, ele apenas cria uma nova referência para o mesmo array.

Veja a diferença na prática:

var original = new int[] { 1, 2, 3 };

// Apenas uma nova referência para o mesmo array
var sameArray = original;
sameArray[0] = 99;
Console.WriteLine(original[0]); // 99

// Uma cópia independente dos elementos
var copy = (int[])original.Clone();
copy[1] = 50;
Console.WriteLine(original[1]); // 2

Como Clone() devolve um object, você precisa fazer a conversão para o tipo do array. Além disso, a cópia é rasa: em um array de objetos, os dois arrays continuam apontando para as mesmas instâncias.

Para entender melhor a diferença entre cópia rasa e cópia profunda, vale a leitura do artigo clonando objetos no C#.

Declarando arrays multidimensionais

Para declarar a matriz da imagem como um array multidimensional 3x2, informamos a quantidade de linhas e de colunas separadas por vírgula:

var rows = 3;
var columns = 2;

// Matriz com 3 linhas e 2 colunas
var multidimensionalArray = new int[rows, columns];

Também é possível declarar de forma mais direta:

var multidimensionalArray = new int[3, 2];

A vírgula dentro dos colchetes indica a quantidade de dimensões. Portanto, int[,] representa duas dimensões, enquanto int[,,] representa três.

Inicializando a matriz

A inicialização na declaração varia de acordo com a dimensão da matriz. Em uma matriz 3x2, cada par de chaves internas representa uma linha:

// Três linhas, cada uma com duas colunas
var multidimensionalArray = new int[3, 2] { { 16, 52 }, { 91, 43 }, { 77, 28 } };

Outra opção é adicionar o valor de cada posição depois, assim como fizemos no vetor:

multidimensionalArray[0, 0] = 16; // primeira linha, coluna um
multidimensionalArray[0, 1] = 52; // primeira linha, coluna dois
multidimensionalArray[1, 0] = 91; // segunda linha, coluna um
multidimensionalArray[1, 1] = 43; // segunda linha, coluna dois
multidimensionalArray[2, 0] = 77; // terceira linha, coluna um
multidimensionalArray[2, 1] = 28; // terceira linha, coluna dois

Observe que, diferente do vetor, atribuir valor à matriz exige informar a linha e a coluna do item. Em uma matriz 2D, pense no índice da esquerda como a linha e no da direita como a coluna.

Lendo itens da matriz

Ler o valor de um item da matriz é tão simples quanto ler de um vetor. Basta chamar a matriz e passar entre colchetes a linha e a coluna desejadas:

// Exibe o valor da primeira linha e primeira coluna (16)
Console.WriteLine(multidimensionalArray[0, 0]);

Com isso, o console exibe o valor da posição indicada. Da mesma forma que no vetor, uma linha ou coluna inexistente gera uma IndexOutOfRangeException.

Percorrendo arrays multidimensionais

Com a matriz definida, podemos percorrer os elementos usando a instrução foreach para exibir os valores no console:

// Percorre todos os elementos, linha por linha
foreach (var item in multidimensionalArray)
    Console.WriteLine($"{item}");

Nos arrays multidimensionais, o foreach incrementa primeiro o índice da dimensão mais à direita. Em outras palavras, ele lê a primeira linha inteira, depois a segunda, e assim por diante, exibindo 16, 52, 91, 43, 77 e 28.

No entanto, o foreach não informa em qual linha e coluna está cada valor. Quando você precisa dessas posições, use dois laços for aninhados com o método GetLength:

// GetLength(0) devolve o número de linhas e GetLength(1) o de colunas
for (var row = 0; row < multidimensionalArray.GetLength(0); row++)
{
    for (var column = 0; column < multidimensionalArray.GetLength(1); column++)
        Console.Write($"{multidimensionalArray[row, column]} ");

    Console.WriteLine();
}

Nesse caso, a saída mostra a matriz em formato de tabela, com uma linha do console para cada linha da matriz.

Atenção a um detalhe importante: em arrays multidimensionais, a propriedade Length devolve o total de elementos de todas as dimensões. Na matriz 3x2, por exemplo, Length vale 6, e por isso não serve como limite do laço de linhas.

Arrays multidimensionais com três dimensões

Os arrays multidimensionais não param em duas dimensões. Você pode criar estruturas com três ou mais, acrescentando vírgulas na declaração:

// Duas "camadas", cada uma com 2 linhas e 3 colunas
var cube = new int[2, 2, 3]
{
    { { 1, 2, 3 }, { 4, 5, 6 } },
    { { 7, 8, 9 }, { 10, 11, 12 } }
};

Console.WriteLine(cube[1, 0, 1]); // 8
Console.WriteLine(cube.Rank);     // 3
Console.WriteLine(cube.Length);   // 12

A propriedade Rank informa a quantidade de dimensões do array. Já o método GetLength, que vimos antes, devolve o tamanho de uma dimensão específica.

Na prática, matrizes com três dimensões aparecem em cenários como grades de voxels, cubos de dados ou camadas de um mapa. Contudo, acima disso o código fica difícil de ler, e geralmente vale modelar os dados com classes.