COMPREENDENDO AS MATRIZES MULTIDIMENSIONAIS

Uma matriz é uma variável que pode armazenar múltiplos valores do mesmo tipo. Em todos os exemplos as matrizes consistiram de uma única fileira de dados (Vetor). No entanto, C também permite matrizes bi, tri e multidimensionais. O melhor modo de visualizar uma matriz bidimensional é com uma tabela com linhas e colunas. Se uma matriz contém três dimensões, visualize-a como várias páginas, cada uma das quais contendo uma tabela bidimensional, como mostrado na Figura abaixo.

As seguintes declarações de matrizes criam as matrizes mostradas na Figura

char strings [64];

int tabela [10][5];

float paginas [10][5][3];

COMPREENDENDO AS LINHAS E COLUNAS

C suporta matrizes multidimensionais que são similares às tabelas de valores. Quando você trabalhar com uma matriz bidimensional, pense na matriz como uma tabela de linhas e colunas. As colunas da tabela vão da esquerda para a direita, enquanto as linhas vão de cima para baixo, como mostrado na Figura abaixo

Ao declarar uma matriz bidimensional, o primeiro valor que você especificar informará o número de linhas; e o segundo valor, o número de colunas:

int tabela [2][3];

ACESSANDO ELEMENTOS EM UMA MATRIZ BIDIMENSIONAL

Como você aprendeu, pode visualizar melhor uma matriz bidimensional como uma tabela que consiste de linhas e colunas. Para referenciar um elemento específico da matriz, você precisa especificar a posição de linha e coluna correspondente. A Figura abaixo ilustra os comandos que acessam elementos específicos dentro de uma matriz tabela.

Para acessar elementos em uma matriz bidimensional, você precisa especificar a posição de linha e coluna do elemento. Como pode ver, quando você acessa uma matriz bidimensional, os deslocamentos de linha e coluna iniciam em 0.

INICIALIZANDO ELEMENTOS EM UMA MATRIZ BIDIMENSIONAL

Vimos que, para inicializar elementos da matriz, você pode colocar os valores do elemento dentro de abre e fecha colchetes após a declaração da matriz. O comando a seguir usa a mesma técnica para inicializar uma matriz bidimensional. No entanto, neste caso, o comando especifica os valores para cada linha da matriz dentro de chaves:

int tabela [2][3] = {{1, 2, 3},{4,5, 6}};

O compilador C inicializará os elementos da matriz, como mostrado na Figura abaixo

Inicializando os elementos de uma matriz bidimensional.

De um modo similar, o comando a seguir inicializa os elementos de uma matriz maior:

int vendas [4][5] {{1, 2, 3, 4, 5},
                   {6,7, 8, 9, 10},
                   {11,12, 13, 14, 15},
                   {16,17, 18, 19, 20}};

DETERMINANDO O CONSUMO DE MEMÓRIA DE UMA MATRIZ MULTIDIMENSIONAL

Você aprendeu que seus programas podem determinar a quantidade de memória que uma matriz consome multiplicando o número de elementos na matriz pelo número de bytes requerido para representar o tipo da matriz (tal como 2 para int, 4 para float e assim por diante). Para determinar a memória que uma matriz multidimensional consome, você pode efetuar o mesmo cálculo. Para determinar o número de elementos em uma matriz multidimensional, simplesmente multiplique o número de linhas pelo número de colunas. As expressões a seguir ilustram a quantidade de memória que diferentes declarações de matriz consomem:

int a [5][10]; // 2*5*10 == 100 bytes

float b [5][8]; // 4*5*8 == 160 bytes

int c [3][4][5]; // 2*3*4*5 == 120 bytes

O programa a seguir, usa o operador sizeof para determinar o número de bytes que as diferentes declarações de matrizes consomem:

#include <stdio.h>
void main (void)
{
  int caixa [3][3];
  float vendas_ano [52][5];
  char paginas [40][60][20];
	
  printf("Memória para int caixa [3][3] %d bytes\n", 
	       sizeof(caixa));
  printf("Memória para float vendas_ano [52][5] %d bytes\n", 
	       sizeof(vendas_ano));
  printf("Memória para char paginas [40][60][20] %ld bytes\n",
	       sizeof (paginas));
}

Quando você compilar e executar o programa sua tela exibirá o seguinte:

Memória para int caixa [3][3] 18 bytes

Memória para float vendas_ano [52][5] 1040 bytes

Memória para char paginas [40][60][20] 48000 bytes

PERCORRENDO EM LAÇO UMA MATRIZ BIDIMENSIONAL

Quando seus programas trabalham com matrizes bidimensionais, você normalmente usa duas variáveis para acessar elementos da matriz. O programa a seguir, usa as variáveis linha e coluna para exibir os valores contidos dentro da matriz tabela:

#include <stdio.h>
void main (void)
{
  int linha, coluna;
  float tabela [3][5] = {{1.0, 2.0, 3.0, 4.0, 5.0},
                         {6.0, 7.0, 8.0, 9.0, 10.0},
                         {11.0, 12.0, 13.0, 14.0, 15.0}};

   for (linha = 0; linha < 3; linha++)
     for (coluna = 0; coluna < 5; coluna++)
         printf ("tabela [%d][%d] = %f\n", linha, coluna,
                 tabela[linha][coluna]);
}

Colocando laços for dentro do outro, como mostrado, o programa exibirá os elementos contidos na primeira linha da matriz (1.0 até 5.0). Em seguida, o programa irá se mover para a próxima linha, e, depois, para a terceira linha, exibindo os elementos dentro de cada linha.

PERCORRENDO UMA MATRIZ TRIDIMENSIONAL

Na dica anterior vimos percorrer uma matriz bidimensional usando duas variáveis chamadas linha e coluna. O programa a seguir, usa as variáveis linha, coluna e tabela para percorrer uma matriz tridimensional:

#include <stdio.h>
void main (void)
{
  int linha, coluna, tabela;
  float valores [2][3][5] = {
                             {{1.0, 2.0, 3.0, 4.0, 5.0},
                              {6.0, 7.0, 8.0, 9.0, 10.0},
                              {11.0, 12.0, 13.0, 14.0, 15.0}},
                             {{16.0, 17.0, 18.0, 19.0, 20.0},
                              {21.0, 22.0, 23.0, 24.0, 25.0},
                              {26.0, 27.0, 28.0, 29.0, 30.0}}
                            };

   for (linha = 0; linha < 2; linha++)
      for (coluna = 0; coluna < 3; coluna++)
         for (tabela = 0; tabela < 5; tabela++)
             printf ("valores [%d][%d][%d] = %f\n", linha, coluna, 
                     tabela, valores [linha][coluna][tabela]);
}

INICIALIZANDO MATRIZES MULTIDIMENSIONAIS

O programa abaixo apresentado na dica anterior, inicializou os valores da matriz tridimensional, como mostrado aqui:

float valores [2][3][5] = {
                            {{1.0, 2.0, 3.0, 4.0, 5.0},
                             {6.0, 7.0, 8.0, 9.0, 10.0},
                             {11.0, 12.0, 13.0, 14.0, 15.0}},
                            {{16.0, 17.0, 18.0, 19.0, 20.0},
                             {21.0, 22.0, 23.0, 24.0, 25.0},
                             {26.0, 27.0, 28.0, 29.0, 30.0}}
                          };

À primeira vista, inicializar uma matriz multidimensional pode parecer confuso. Para compreender melhor como inicializar essas matrizes, esta dica apresenta várias inicializações de exemplo. À medida que você examina as inicializações, faça as inicializações da direita para a esquerda.

							
int a [1][2][3] = {
                    { {1, 2, 3}, {4, 5, 6} }
                  } // Chaves da matriz
int b [2][3][4] = {
                    { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} },
                    { {13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 34} }
                  }; // Chaves da matriz
int c [3][2][4] = {
                    { {1, 2, 3, 4}, {5, 6, 7, 8} },
                    { {9, 10, 11, 12}, {13, 14, 15, 16} },
                    { {17, 18, 19, 20}, {21, 22, 23, 24} }
                   }; // Chaves da matriz

Cada inicialização de matriz recebe um conjunto de chaves externas. Dentro das chaves externas, você então define os diferentes elementos da matriz dentro de chaves adicionais.

COMPREENDENDO COMO C ARMAZENA MATRIZES MULTIDIMENSIONAIS

Você aprendeu que, quando declara uma matriz, tal como int notas [100], C aloca memória suficiente para conter cada elemento da matriz. Quando você aloca uma matriz multidimensional, o mesmo é verdadeiro. Embora as matrizes multidimensionais conceitualmente consistam de linhas, colunas e páginas, para o compilador, uma matriz multidimensional é uma seqüência longa de bytes. Por exemplo, assuma que seu programa declare a seguinte matriz:

int tabela [3][5];

A Figura a seguir ilustra a aparência conceitual da matriz e o uso real da memória.

Como o compilador C na verdade mapeia a matriz multidimensional como um intervalo de memória de uma dimensão, é válido tratar a matriz como uma dimensional.

COMPREENDENDO A ORDEM LINHA POR LINHA VERSUS COLUNA POR COLUNA

Quando o compilador mapeia uma matriz multidimensional na memória, ele tem duas opções. Como mostrado na Figura a seguir, o compilador pode colocar os elementos da linha da matriz antes dos valores da coluna, ou o compilador pode colocar os elementos da coluna primeiro.

Quando o compilador coloca os elementos da linha da matriz na memória antes dos elementos da coluna, o compilador está efetuando a ordenação por linha. Da mesma forma, quando o compilador coloca os elementos da coluna primeiro, ele efetua a ordenação por coluna. Os compiladores C armazenam matrizes multidimensionais na ordem linha por linha.