Adresse d'un tableau ?

Actuellement, la fonction ADR() peut retourner l'adresse de la première cellule d'un tableau en une dimension. Les cellules suivantes étant mémorisées en continu à la suite, il est donc facile d'accéder aux données d'un tableau en 1 dimension. C'est très bien !

Par contre, cela ne marche pas pour un tableau en 2 dimensions. Ou plutôt, ça ne marche que partiellement. Car, pour un tableau en 2 dimensions, la mémorisation des données se fait par portions contigues mais distinctes, pour chaque élément du second indice.

Pour un tableau déclaré comme
dim buf%(5,10)
La fonction ADR( retourne alors l'adresse de la première cellule bif%(0,0), ce qui donne accès à toutes les cellules buf%(0,0) jusqu'à buf%(0,10). Par contre, buf%(1,0), buf%(2,0) etc et leurs "suites" sont mémorisées ailleurs, pas en continuité avec buf%(0,10), ce qui rend impossible, dans une DLL, d'accéder à la totalité du tableau. Et si Jack envisage, à l'avenir, d'implémenter des tableaux à plusieurs dimensions, ce sera encore plus limitatif. Le problème est encore plus complexe lorsqu'on sait que les "sections" de données sont mémorisées dans des zones mémoire distinctes en fonction du type de tableau (entier, flottant ou chaîne de caractères).

D'où ma suggestion: deux solutions !

1ère solution: rendre l'ensemble des données accessibles par une fonction spéciale:
ADR_ARRAY(N,I...[,K])
N étant le nom du tableau
I étant une valeur valide du premier indice
...
K étant une valeur valide du dernier indice
La fonction retournerait l'adresse de la cellule N(I,...,K)
Ceci aurait un sens et pourrait marcher pour tout nombre de dimensions, et l'ensemble des données serait alors accessible. Car pour accéder à la série contigue pour le seond indice = 3, il suffirait alors de passer
a% = ADR_ARRAY(N,0,3)
On obtient l'adresse de la cellule N(0,3) et c'est exactement ce qu'il faut. Effet secondaire:
a% = ADR_ARRAY(N,0,0)
est identique à
A% = adr(N)

2ème solution: mémoriser physiquement les données dans un espace contigu unique.
Elles seraient mémorisées dans l'ordre actuel, mais pas par sections disjointes. La fonction ADR() serait alors parfaitement suffisante. Sachant que le programme connaît évidemment les dimensions, on peut facilement calibrer les transferts. Mais on peut également facilement retrouver ces dimensions dans la table de symboles.

Salut Klaus

L’affichage n’est pas le même.
Où trouve-t-on les valeurs du vecteur ?

Code:

dim n : n = 10
dim vecteur(n-1)
dim i
dim adresse
adresse = adr(vecteur)
for i = 0 to n-1
    vecteur(i) = int(rnd(100))
    print vecteur(i) ; "  ";
next i
print

for i = adresse to adresse + n-1
    print peek(i) ; "  ";
next i

Normal. PEEK retourne un octet, pas un mot de 32 bits, encore moins un flottant...

Ok maître Klaus

Voici comment faire

Code:

dim n : n = 10
dim vecteur%(n-1)
dim i
dim adresse
adresse = adr(vecteur%)
for i = 0 to n-1
    vecteur%(i) = int(rnd(100))
    print vecteur%(i) ; "  ";
next i
print

for i = adresse to adresse + 4*(n-1) step 4
    print peek(i) ; "  ";
next i

Oui, si tu n'utilises que l'octet de poiids faible...

Voici ton code, adapté à la lecture de mots de 32 bits (2 méthodes):

Code:

    dim v%
    dim n : n = 10
    dim vecteur%(n-1)
    dim i
    dim adresse, adresse2
    adresse = adr(vecteur%)
    adresse2 = adr(v%)
   
    for i = 0 to n-1
        vecteur%(i) = int(rnd(100000))
        print vecteur%(i) ; "  ";
    next i
    print

    for i = adresse to adresse + 4*(n-1) step 4
        v% = peek(i+3)
        v% = v%*256 + peek(i+2)
        v% = v%*256 + peek(i+1)
        v% = v%*256 + peek(i)
        print v% ; "  ";
    next i
    print

    for i = adresse to adresse + 4*(n-1) step 4
        poke adresse2,peek(i)
        poke adresse2+1,peek(i+1)
        poke adresse2+2,peek(i+2)
        poke adresse2+3,peek(i+3)
        print v% ; "  ";
    next i

Pour relancer ma suggestion, suite à l'aparté, j'ai complété mon post initial avec quelques précisions.