les multis tableaux

[graph100]

les tableaux ont plein d'avantages sur les listes chainés notamments les acces qui sont beaucoup plus rapides. mais il faut prevoir un nombre fixe de tableaux dans le code.

Pour bien voir a quoi je veut en venir : un prog ne peut pas créer (ou je ne sait pas le faire) de tableau.

je pense a une fonction du type:

Code : Tout sélectionner

For a = 0 to 5
  nomdutableau.s = "tableau" + str(a)
  DimTableau nomdutableau.s(dimention1, dimention2, ...)
Next

en gros une fonction Dim dans laquelle le nom du tableau est une variable
evidement il faudrait aussi modifier les fonctions d'acces aux tableaux

[lionel_om]

Rien ne t'empèche d'utiliser une dimension supplémentaire ou sinon ca doit pouvoir se faire avec les macros. Les spécialistes des Macro te répondront peut-être, sinon recherche sur le forum cela a déja été cité !!!

Lio

[Guimauve]

Bonjour,

Je ne pense pas que ce soit possible même avec les Macros. Le seul moyen d'arriver à faire quelque chose serait de manipuler soi-même les blocs mémoires. Les "AllocateMemory()" et avec soit un tableau, soit une liste chainé contenant les adresses mémoires de chacun des blocs alloués.

Si j'ai le temps, je ferai un petit exemple.

A+
Guimauve

[graph100]

@lionel_om
la dimention suplémentaire ne peut pas fonctionne car les tableaux n'ont pas les memes dmentions : ce sont des objets a par entiere tous differents

je pensais a une indexations des noms de tableau

mais c'est une modification faire dans pure par Fred

[Backup]

les tableaux ont plein d'avantages sur les listes chainés notamments les acces qui sont beaucoup plus rapides. mais il faut prevoir un nombre fixe de tableaux dans le code.

Pour bien voir a quoi je veut en venir : un prog ne peut pas créer (ou je ne sait pas le faire) de tableau.

je pense a une fonction du type:

Code : Tout sélectionner

For a = 0 to 5
  nomdutableau.s = "tableau" + str(a)
  DimTableau nomdutableau.s(dimention1, dimention2, ...)
Next

en gros une fonction Dim dans laquelle le nom du tableau est une variable
evidement il faudrait aussi modifier les fonctions d'acces aux tableaux

ben il me semble que les structures c'est ça non ?

Code : Tout sélectionner

Structure nomdutableau
    dimention1.l
    dimention2.l
EndStructure
Dim nomdutableau.nomdutableau(6)





; ici "a" joue le role du nom de tableau 
For a = 0 To 5 
    element1=nomdutableau(a)\dimention1 ; tu as bien acces aux elements des tableaux
   element2= nomdutableau(a)\dimention2 ; mais de façon individuel
Next a

[Anonyme]

les listes chainées sont plus rapides que les tableaux en écriture et en lecture, le top , c'est les blocs de mémoires. la méthode a dobro est très bien, fait des comparatif avec des tableaux simple , double , triple , simple avec structure... liste chainée , etc.. tu veras que les liste sont + rapide que les tableaux.

@++

[graph100]

Il me semble que j'avait fait un code pour voir la difference entre tableau et listes chainées et avec les tableaux c'étais tres rapide , il y avait une enorme difference , mais ca a peut etre changer avec la version 4

Hum, et avec tes structures Dobro peut tu faire des tableaux avec differentes dimention. En sachant que le nombre de tableau a utilise est inconnu au lancement du prog.

Par exemple (c'est un exemple sur les tableaux alors ne cherchez pas a dire qu'il y a des commandes toutes pretes qui marchent du tonnerre)
un progamme qui affiche des objets 3D en fonction des leurs coordonnés .
au demarrage il ouvre un dossier dans lequel vous aurait mit les fichiers de coordonnes , ils les ouvrent les uns apres les autres , mais pour pouvoir les afficher il lui faut un tableau a 2 dimentions de taille depandant de l'objet pour chaque objet 3D

Maintenant si on fait la meme chose mais il y a un bouton pour créer de nouveau objet , le probleme et le meme !

il faut manipuler les tableaux comme des objets (images, sprites, gadget), avec un numero

[Backup]

Hum, et avec tes structures Dobro peut tu faire des tableaux avec differentes dimention. En sachant que le nombre de tableau a utilise est inconnu au lancement du prog.

mon exemple a 2 dimentions !!
il me semble que tu n'es pas tres familier des structures !!

Par exemple (c'est un exemple sur les tableaux alors ne cherchez pas a dire qu'il y a des commandes toutes pretes qui marchent du tonnerre)

avec une phrase comme celle la, tu ne trouvera plus personne pour te trouver une solution, c'est clair ! ..

[Anonyme]

Pour en revenir à ton premier post, ton but c'est de créer des tableaux de manière dynamique, c'est à dire en fonction d'un fichier, de datas, bref , de quelque chose que tu ne connais pas d'avance.

Dans se cas :

- Les listes chainées couplé à des structures font largement l'affaire. ( de plus, d'après un de mes benchmark, les linked list, sont plus rapide que les tableaux )

- Si tu es un tendu, rien ne t'empêche d'utilisé des allocatememory() ( c'est la méthode que je préfère pour un gros projet par exemple )

@++

[graph100]

@ Dobro

Citation:

Par exemple (c'est un exemple sur les tableaux alors ne cherchez pas a dire qu'il y a des commandes toutes pretes qui marchent du tonnerre)

avec une phrase comme celle la, tu ne trouvera plus personne pour te trouver une solution, c'est clair ! ..

Je parlais des fonction pour la 3D. enfin bon..

graph100 a écrit:

Hum, et avec tes structures Dobro peut tu faire des tableaux avec differentes dimention. En sachant que le nombre de tableau a utilise est inconnu au lancement du prog.

mon exemple a 2 dimentions !!
il me semble que tu n'es pas tres familier des structures !!

Je voulais dire : tu créer un tableau a 2 dimentions, puis un tableau a 4 dimention par exemple ca veut dire qu'il faut prevoir un nombre maximum
et on perd l'interet des objet.

@Cpl.Bator
Des allocatememory() ?, et on recupere les données avec poke et peek ?
A propos les tableaux ne sont-ils pas un genre d'allocatememory() avec des commandes particulieres ?

Quand tu utilise les listes chaine es que tu prend SelectElement() ou PreviousElement() / NextElement() ??
parceque j'utilise uniquement SelectElement() et c peut etre ca qui me ralenti ?

[Backup]

@ Dobro

Je voulais dire : tu créer un tableau a 2 dimentions, puis un tableau a 4 dimention par exemple ca veut dire qu'il faut prevoir un nombre maximum
et on perd l'interet des objet.

ben avec les Dim , tu ne peux pas non plus creer un tableau a 2 dimensions
puis le modifier pour en faire un de 4 dimensions

en réalité, il ne s'agit plus du meme tableau !!

bon , il me semble que tu n'as pas compris mon sujet sur les structures

voici un exemple qui cree 2 tableaux traditionel , et l'equivalent en structure
pour que tu vois que cela marche en fait pareil
(depuis que j'ai compris comment marche les structures, je ne m'en passe plus !! )

; ****************** exemple traditionel avec 2 tableaux ***********************
; ***********************************************************************************

dimension1=100
dimension2=100
dimension3=100
Dim tableaua (dimension1,dimension2)
Dim tableaub (dimension1, dimension2, dimension3)

tableaua(2,2)=5
tableaub(3,3,3)=5

; ****************** reviens a faire ceci en utilisant les structures !!! ***********************
; ***********************************************************************************
total=100

Structure tableau_a
    dimension1.l
    dimension2.l
EndStructure
Dim tableau_a.tableau_a(total)

Structure tableau_b
    dimension1.l
    dimension2.l
    dimension3.l
EndStructure
Dim tableau_b.tableau_b(total)

tableau_a(2)\ dimension1.l=5:tableau_a(2)\ dimension2.l=5 ; on accede individuellement au membre du "tableau"

tableau_b(3)\ dimension1.l=5:tableau_b(3)\ dimension2.l=5:tableau_b(3)\ dimension3.l=5

[Anonyme]

Voici un exemple d'utilisation des allocatememory()
Attention, cela à l'air compliqué & cie, mais en fait c'est hyper simple.

Code : Tout sélectionner

Structure MyStruct
  A.l
  B.l
EndStructure



Macro DIM_(NAME,STRUCT,SIZE_X,SIZE_Y)
NAME = AllocateMemory(SIZE_X * SIZE_Y * SizeOf(STRUCT))
EndMacro


Macro ADD_(NAME,STRUCT,SIZE_X,CHAMP,X,Y,VALUE)
PokeL(NAME + (X * SizeOf(STRUCT)) * SIZE_X * (Y*SizeOf(STRUCT))+(CHAMP*4) ,VALUE)
EndMacro

Macro DEBUG_(NAME,STRUCT,SIZE_X,CHAMP,X,Y)
Debug PeekL(NAME + (X * SizeOf(STRUCT)) * SIZE_X * (Y*SizeOf(STRUCT))+(CHAMP*4))
EndMacro


DIM_(Bob,MyStruct,10,10)

For i = 0 To 9
  ADD_(Bob,MyStruct,10,0,i,i,10*i)
  ADD_(Bob,MyStruct,10,1,i,i,5*i)
Next 

Debug "MyStruct\A = "
For i = 0 To 9
  DEBUG_(Bob,MyStruct,10,0,i,i)
Next 

Debug "MyStruct\B = "
For i = 0 To 9
  DEBUG_(Bob,MyStruct,10,1,i,i)
Next 

[Kwai chang caine]

Bonjour CPL

Ce n'est peut etre pas compliqué pour toi, mais pour moi ....

Et meme l'interpreteur, il y trouve compliqué, il comprend pas tout, car il met un coup de crayon rouge à la ligne 25

[Anonyme]

Salut kcc, c'est fait sous linux, donc c'est peut être pas pareil.
le principe est très simpliste :

Code : Tout sélectionner

Structure MyStruct 
  A.l 
  B.l 
EndStructure 



Macro DIM_(NAME,STRUCT,SIZE_X,SIZE_Y) 
NAME = AllocateMemory(SIZE_X * SIZE_Y * SizeOf(STRUCT)) 
EndMacro 

j'alloue de la mémoire, d'une taille de (X * Y)
le Sizeof() permet de prendre en compte la taille de la structure.
un tableau à 2 dimension de long d'une taille de 10,10 fait en mémoire 10*10*4 , 4 car un long fait 4 octets en mémoire.
soit 400 octets au final, ici ma structure fait 8 octets ( elle est composé de deux long )
donc 10*10*8 = 800 octets.

une fois l'espace mémoire alloué on devrait le testé pour evité les crash.
ensuite le plus "dur" c'est de se balader dans la zone mémoire pour écrire et recuperer des données :


Macro ADD_(NAME,STRUCT,SIZE_X,CHAMP,X,Y,VALUE)
PokeL(NAME + (X * SizeOf(STRUCT)) * SIZE_X * (Y*SizeOf(STRUCT))+(CHAMP*4) ,VALUE)
EndMacro


pour simplifier l'écriture :

*ZoneMemoire + ( X * SizeOf(STRUCT)) * Largeur_en_X * ( Y * SizeOf(STRUCT))

*ZoneMemoire est le pointeur vers ton espace mémoire alloué.
X & Y est la position dans la zone mémoire ( imagine un tableau à 2 dims )
Largeur_en_x est la taille en x de ton tableau ( le nombre d'éléments )

Voilà , le principe, exerce toi à faire des buffers d'écran avec des allocatememory() , tu verras , une fois compris , c'est très simple.

[graph100]

Voila a quoi je pensais mais ca n'est pas au point totalement
car les procedures d'ecrire ou macro ne s'adaptent pas en fonction de la stucture du tableau

Code : Tout sélectionner

Procedure CreateTableau(nb_dim.l, *tab.Long, struct_size.l)
  Dim dimention_z.l(nb_dim)
  
  taille.l = struct_size
  
  For i = 1 To nb_dim
    *tab + 4
    
    taille * *tab\l
    dimention_z(i) = *tab\l
  Next
  
  taille + 4 * (nb_dim + 1)
  
  *res = AllocateMemory(taille)
  
  If *res
    PokeL(*res, nb_dim)
    For i = 1 To nb_dim
      PokeL(*res + i * 4, dimention_z(i))
    Next
  EndIf
  
  ProcedureReturn *res
EndProcedure


Macro GetLong2dim(adr, x, y)
  PeekL(adr + (PeekL(adr) + x + (y - 1) * PeekL(adr + 4)) * 4)
EndMacro

Macro SetLong2dim(adr, x, y, value)
  PokeL(adr + (PeekL(adr) + x + (y - 1) * PeekL(adr + 4)) * 4, value)
EndMacro


NewList mesTableau()

Dim dimention_du_nouveau_tableau.l(2)


For i = 1 To 10
  AddElement(mesTableau())
  
  dimention_du_nouveau_tableau(1) = (Random(5) + 1) * 10
  dimention_du_nouveau_tableau(2) = (Random(5) + 1) * 10
  
  
  mesTableau() = CreateTableau(2, dimention_du_nouveau_tableau(), SizeOf(Long))
  
  
  Debug "nb dimention : " + Str(PeekL(mesTableau()))
  Debug "dimention 1 : " + Str(PeekL(mesTableau()  + 4))
  Debug "dimention 2 : " + Str(PeekL(mesTableau()  + 8))
  
  x = 1
  y = 2
  
  SetLong2dim(mesTableau(), 2, 4, 12)
  
  Debug GetLong2dim(mesTableau(), 2, 4)
Next