Alors d'abord comment on représente une matrice à une dimension.
En voici une:
[0, 1, 2, 5]
Sous 8086 les entiers sont codés sur 16 bits puisque les registres ont cette taille.
Chacun de ces nombres sera codé sur deux octets donc. Si le premier élément est à l'adresse 0, alors le second est à l'adresse 0 + 2 (car 16 bits ça fait deux octets). Le troisième élément est à 0 + 4 etc...
adresse i + 6 | 5 |
adresse i + 4 | 2 |
adresse i + 2 | 1 |
adresse i | 0 |
Donc mettons que l'adresse de la matrice (donc l'adresse du premier élément soit dans bx), si tu veux mettre la valeur du deuxième élément dans ax, tu fais comme ça:
mov ax, [bx + 2]
En gros là règle c'est: pour accéder à l'élément i, je prends son adresse de base et j'y ajoute i * 2, sachant que l'indice de la matrice i commence à 0 dans cet exemple:
adresse_element[i] = adresse_base + (i * 2)
Maintenant prenont une matrice à 3 dimensions:
[0, 1]
[2, 3]
[4, 5]
Impossible de représenter ça réellement en mémoire, puisqu'elle se présente comme une longue ligne de case à un seul étage.
Alors du coup on transforme notre matrice 3 dimensions en une matrice 1 dimension. Comment me diras-tu? Eh bien on fait comme si les lignes qui suivent la première étaient mises à sa suite.
Tout bonnement ça donne ça:
[0, 1, 2, 3, 4, 5]
Donc si l'indice de la ligne est i, que l'indice de la colonne est j, et que ces indices commencent à 0, et que le nombre d'éléments dans une ligne est de N, alors l'adresse d'un élement de ta matrice est:
adresse_element[i][j] = adresse_base + (i * N * 2) + (j * 2)
Valà!
