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:

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

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

int a [3] [] = 1,2,3,4,5,6;
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 2^nd linha e 3^rd 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 1^st 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 1^st 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 1^st 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

Declaração de Matriz 2D
Inicialização da matriz 2D
Mapeamento de memória da matriz 2D
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

Fedora

Como ativar o repositório de fusão de RPM no Fedora

Tutorial abrangente sobre como habilitar os repositórios de pacotes sem fusão e não-livres do RPM no...

Pedro Macejkovic

Banco de dados Oracle

Como cache a sequência Oracle para melhorar os recursos do dicionário de dados?

As opções cache, noorder e mantenha podem ser utilizadas para armazenar em cache a sequência do Orac...

Shaun Bogan

C nítido

Quebre e continue declarações em C#

A declaração de quebra pode sair de um loop mais cedo, enquanto continua pode pular sobre certas ite...

Benny Hilll DDS