Matriz 2D

Matriz 2D
Uma matriz bidimensional (2D) é uma matriz de uma dimensão (1d) matrizes. Os tamanhos de matriz 1D são iguais. A matriz 2D também é chamada de matriz com linhas e colunas.

Vamos ver o seguinte exemplo:

Essas 3 matrizes 1D podem ser representadas como uma matriz 2D da seguinte forma:

Vamos ver outro exemplo:

Essas 3 matrizes 1D não podem estar representando como uma matriz 2D, porque os tamanhos das matrizes são diferentes.

Declaração de Matriz 2D

tipo de dados nome de matriz[[LINHA] [Col]

  • Tipo de dados é o tipo de dados dos elementos da matriz.
  • Nome de matriz é o nome da matriz.
  • Dois subscritos representam o número de linhas e colunas da matriz. O número total de elementos da matriz será Row*Col.

int a [2] [3];

Usando o código C acima, podemos declarar um Inteiro variedade, a de tamanho 2*3 (2 linhas e 3 colunas).

Char B [3] [2];

Usando o código C acima, podemos declarar um personagem variedade, b de tamanho 2*3 (3 linhas e 2 colunas).

Inicialização da matriz 2D

Podemos inicializar durante a declaração das seguintes maneiras:

  1. int a [3] [2] = 1,2,3,4,5,6;
  2. int a [] [2] = 1,2,3,4,5,6;
  3. int a [3] [2] = 1, 2, 3, 4, 5, 6;
  4. int a [] [2] = 1, 2, 3, 4, 5, 6;

Observe que em 2 e 4 não mencionamos o 1st subscrito. O compilador C calcula automaticamente o número de linhas do número de elementos. Mas o 2nd Subscrito deve ser especificado. A seguir, as inicializações são inválidas:

  1. int a [3] [] = 1,2,3,4,5,6;
  2. int a [] [] = 1,2,3,4,5,6;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//Exemplo 1.c
#incluir
#Define Row 3
#Define Col 2
int main ()

int i, j;
int a [linha] [col] =
1,2,
3,4,
5,6
;
printf ("Elementos sábios da matriz A são: \ n");
para (i = 0; i
printf ("Linha %d:", i);
para (j = 0; j
printf (" %d", a [i] [j]);

printf ("\ n");

printf ("\ n \ nColumn Wise Elements of the Array A são: \ n");
para (i = 0; i
printf ("Column %d:", i);
para (j = 0; j
printf (" %d", a [j] [i]);

printf ("\ n");

retornar 0;

No exemplo1.C, declaramos uma matriz inteira de tamanho 3*2 e inicializamos. Para acessar elementos da matriz, usamos dois para loop.

Para acessar em termos de remar, o loop externo é para linhas, e o loop interno é para colunas.

Para acessar em termos de coluna, o loop externo é para colunas, e o loop interno é para linhas.

Observe que quando declaramos uma matriz 2D, usamos um [2] [3], o que significa 2 linhas e 3 colunas. A indexação de matriz começa em 0. Para acessar o 2nd linha e 3rd coluna, temos que usar a notação a [1] [2].

Mapeamento de memória de uma matriz 2D

A visão lógica de uma matriz A [3] [2] pode ser o seguinte:

A memória do computador é uma sequência 1D de bytes. Na linguagem C, uma loja 2D de matriz na memória em Ordem-major de linha. Algumas outras linguagens de programação (e.g., Fortran), ele armazena em Ordem da coluna-major na memória.

Aritmético de ponteiro de uma matriz 2D

Para entender a aritmética do ponteiro da matriz 2D, primeiro, dê uma olhada na matriz 1D.

Considere uma matriz 1D:

Na matriz 1D, a é uma constante e seu valor é o endereço do 0º Localização da matriz A [5]. Valor de a+1 é o endereço do 1st Localização da matriz A [5]. a+i é o endereço do euº Localização da matriz.

Se incrementarmos a por 1, é incrementado pelo tamanho do tipo de dados.

A [1] é equivalente a *(a+1)

A [2] é equivalente a *(a+2)

A [i] é equivalente a *(a+i)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Exemplo2.c
#incluir
#Define Row 3
#Define Col 2
int main ()

int a [5] = 10,20,30,40,50;
printf ("sizeof (int): %ld \ n \ n", sizeof (int));
printf ("A: %p \ n", a);
printf ("A+1: %p \ n", a+1);
printf ("A+2: %p \ n \ n", a+2);
printf ("a [1]: %d, *(a+1): %d \ n", a [1], *(a+1));
printf ("a [2]: %d, *(a+2): %d \ n", a [1], *(a+1));
printf ("a [3]: %d, *(a+3): %d \ n", a [1], *(a+1));
retornar 0;

No exemplo2.C, o endereço de memória está aparecendo em hexadecimal. A diferença entre A e A+1 é 4, que é o tamanho de um número inteiro em bytes.

Agora, considere uma matriz 2D:

b é um ponteiro do tipo: int [] [4] ou int (*) [4]

int [] [4] é uma fileira de 4 inteiro. Se incrementarmos B em 1, é incrementado pelo tamanho da linha.

b é o endereço do 0º linha.

B+1 é o endereço do 1st linha.

b+i é o endereço de euº linha.

O tamanho de uma linha é: (Número de coluna * sizeof (tipo de dados)) bytes

O tamanho de uma linha de uma matriz inteira B [3] [4] é: 4 * sizeof (int) = 4 * 4 = 16 bytes

Uma fileira de uma matriz 2D pode ser vista como uma matriz 1D. b é o endereço do 0º linha. Então, temos o seguinte

  • *B+1 é o endereço do 1st elemento do 0º
  • *B+J é o endereço do jº elemento do 0º
  • *(B+i) é o endereço do 0º elemento do euº
  • *(b+i)+j é o endereço do jº elemento do euº
  • B [0] [0] é equivalente a ** b
  • B [0] [1] é equivalente a *( *B+1)
  • B [1] [0] é equivalente a *( *(B+1))
  • B [1] [1] é equivalente a *( *(B+1) +1)
  • b [i] [j] é equivalente a *( *(b+i)+j)

Endereço de B [i] [J]: B + Sizeof (tipo de dados) * (número de coluna * i + j)

Considere uma matriz 2D: int b [3] [4]

Endereço de B [2] [1] é : b + sizeof (int) * (4 * 2 + 1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// Exemplo3.c
#incluir
#Define Row 3
#Define Col 4
int main ()

int i, j;
int b [linha] [col] =
10,20,30,40,
50,60,70,80,
90.100.110.120
;
printf ("sizeof (int): %ld \ n", sizeof (int));
printf ("tamanho de uma linha: %ld \ n", col*sizeof (int));
printf ("b: %p \ n", b);
printf ("b+1: %p \ n", b+1);
printf ("b+2: %p \ n", b+2);
printf ("*b: %p \ n",*b);
printf ("*b+1: %p \ n",*b+1);
printf ("*b+2: %p \ n",*b+2);
printf ("b [0] [0]: %d ** b: %d \ n", b [0] [0], ** b);
printf ("b [0] [1]: %d*(*b+1): %d \ n", b [0] [1],*(*b+1));
printf ("b [0] [2]: %d*(*b+2): %d \ n", b [0] [2],*(*b+2));
printf ("b [1] [0]: %d*(*(b+1)): %d \ n", b [1] [0],*(*(b+1)));
printf ("b [1] [1]: %d*(*(b+1) +1): %d \ n", b [1] [1],*(*(b+1) +1) );
retornar 0;

No exemplo3.C, vimos que o tamanho de uma linha é 16 em notação decimal. A diferença entre B+1 e B é 10 em hexadecimal. 10 em hexadecimal é equivalente a 16 em decimal.

Conclusão

Então, neste artigo, aprendemos sobre

  1. Declaração de Matriz 2D
  2. Inicialização da matriz 2D
  3. Mapeamento de memória da matriz 2D
  4. Aritmético de ponteiro de 2D

Agora podemos usar a matriz 2D em nosso programa C sem dúvida,

Referências

O crédito por algumas idéias neste trabalho foi inspirado no curso, Pontenters e Matrizes 2D, pelo Departamento de Ciência da Computação e Engg de Palash Dey. Instituto Indiano de Tecnologia Kharagpur