Array() vide ?

[selzig]

Bonjour,

en PB, il semble que l'on ne puisse pas

• créer un tableau (dynamique) vide (i.e. 0 lignes)
• rendre un tableau (dynamique) vide

...puisque Dim MonTableau(0) crée ou recrée un tableau contenant une ligne (même si elle est vide)

Ai-je bien compris ou suis-je passé à côté de quelque chose ?

Merci. Gilles

[case]

salut je ne comprend pas ou tu veux en venir
tu ne peux pas créer un tableau sans profondeur par défaut la valeur est 0
ca reviendrais dans la vrais vie a créer un tiroir mais sans place pour ranger dedans

Code : Tout sélectionner

Dim montableau(0)
montableau(0)=1
Debug montableau(0)
Dim montableau(0)
Debug montableau(0)
montableau(0)=1
ReDim montableau(1)
Debug montableau(0)
Debug montableau(1)

sinon il y a les listes pour cela

Code : Tout sélectionner

Dim montableau(0)
montableau(0)=1
Debug montableau(0)
Dim montableau(0)
Debug montableau(0)
montableau(0)=1
ReDim montableau(1)
Debug montableau(0)
Debug montableau(1)
Debug "---------liste ------------"

NewList maliste()
Debug ListSize(maliste())
AddElement(maliste())
maliste()=1
Debug ListSize(maliste())
SelectElement(maliste(),0)
Debug maliste()
AddElement(maliste())
maliste()=2
AddElement(maliste())
maliste()=3
For sh=0 To ListSize(maliste())-1
  SelectElement(maliste(),sh)
  Debug maliste()
Next

[selzig]

Bonjour Case,

En ce qui concerne les tableaux, je considère cela comme une originalité (i.e. cela n'a rien de naturel) :

Supposons que mon tableau s'appelle Pages()
1. Il ne peut pas contenir "rien". Un tableau qui ne contient rien mais est simplement déclaré cela ne me semble pas absurde. Surtout si c'est un tableau dynamique. En PB, visiblement, la création s'accompagne obligatoirement d'un peuplement.
2. Pour savoir s'il est vide, je n'ai trouvé pour tester que

Code : Tout sélectionner

If ArraySize(Pages()) = 0 And Pages(0) = "" 

Cela me parait aussi désopilant que si vous m'affirmiez que pour exister une table de BDD doit contenir un enregistrement. Donc un code genre Pages().isEmpty est impossible en PB me semble-t-il ? Il est vrai que je viens de la programmation objet... On définit d'abord l'objet et ensuite on utilise ses propriétés et ses méthodes. Ceci explique peut-être cette question.

Merci. Je note qu'il y a les listes. Je regarde cela.
Cordialement. Gilles

[falsam]

Ai-je bien compris ou suis-je passé à côté de quelque chose ?

Tu as bien compris ^-^
Mais est ce gênant ?

Solution : Les listes chaînées et les maps.

Code : Tout sélectionner

Structure NewElement
  a.s
  b.i
EndStructure

NewList Elements.NewElement()

Debug ListSize(Elements())

CallDebugger

Menu -> Débogueur -> Voir les variables -> Listes chaînées - > Clic droit sur Elements() -> Afficher tous les éléments.

La liste est vide.

[Ar-S]

Bonjour
Je pense que si ton MonTableau(0) te retourne 0 il ne faut pas le prendre comme une valeur mais comme un Flag indiquant justement que le tableau est Null. Enfin je suppose

[selzig]

Bonjour Ar-S,

Il ne me semble pas parce que MonTableau(0) représente la première ligne du tableau. Vous pouvez mettre ce que vous voulez dans cette première ligne. Lorsque l'on écrit

Code : Tout sélectionner

Dim MonTableau(0)

MonTableau est créé avec un premier enregistrement vide.
Donc dans le cas d'un tableau dynamique, quand vous faites une boucle de remplissage à partir de la création, il faut incorporer un if pour distinguer le cas de l'enregistrement 0 (qu'il suffit de remplir) des enregistrements suivants pour lesquels auparavant il faut ajouter une ligne

Code : Tout sélectionner

Redim MonTableau(Arraysize(MonTableau())+1)
MonTableau(Arraysize(MonTableau()) = ...

Compte tenu de l'allure des codes nécessaires, je me suis dit que je n'étais pas dans le coup. Et effectivement List est plus adapté. Mais compte tenu de mes habitudes de programmation, l'array m'a semblé s'imposer naturellement.
Cordialement. Gilles

[Fig]

La vraie et seule question est de savoir en quoi cela te contrarie t il ? Qu'est ce que ça change pour toi ?

Je ne vois qu'un problème en l’occurrence, c'est la perte de mémoire lorsqu'on créé une structure contenant des tableaux vides.
Mais franchement avec la taille de nos mémoires actuelles de nos pc, je ne vois pas trop en quoi cela peut poser un vrai problème.

Ceci étant dit, initialiser les tableaux que lorsqu'ils se peuplent pour la première fois n'est pas plus logique si on y pense. C'est juste un choix.

Je crois que Fre4k en a parlé sur son blog.

Au pire tu peux toi même allouer la mémoire dont tu as besoin pour ton tableau avec allocatememory() en temps et en heure, comme ça, tu auras l'esprit tranquille...

[case]

En ce qui concerne les tableaux, je considère cela comme une originalité (i.e. cela n'a rien de naturel) :

mais c'est le cas depuis l'existence du Basic aussi loin que je m'en souvienne.
qui a dit qu'un langage était naturel ^^ le français, l'anglais, l'allemand,le finnois, l’algérien, le chinois sont tous différents avec leurs règles et leurs particularités
tout comme le Basic, lua,l'assembleur, le c le pascal le Fortran ont aussi leurs particularités et leurs règles

[Marc56]

Sans oublier qu'en plus de le redimensionner (ReDim) , on peut le supprimer totalement à tout moment: FreeArray()

Cela dit, quand on n'a pas besoin de plusieurs dimensions ou d'un accès direct, les Listes ont bien plus de possibilités intéressantes.

[Ollivier]

Bonjour,
en PB, il semble que l'on ne puisse pas
créer un tableau (dynamique) vide (i.e. 0 lignes)
rendre un tableau (dynamique) vide
...puisque Dim MonTableau(0) crée ou recrée un tableau contenant une ligne (même si
elle est vide)
Ai-je bien compris ou suis-je passé à côté de quelque chose ?

Tu es passé à côté de quelque chose... Et qui a des redondances à 2 niveaux de programmation. (Dans la continuité des détails techniques évoqués par autrui ci-dessus) Voici un exemple...

Code : Tout sélectionner

;********************************************************************************************************************************************************
; Je décide : "IntegerArray" comme "Tableau d'entiers" mais le programmeur est libre de nommer ça comme il veut et même de faire des faute d'accord....

Structure IntegerArray
         Array Value.I(0)
EndStructure

; "T" comme (t)ableau, c'est moi qui ai décidé : même topo, libre au programmeur de baptiser son pointeur comme il l'entend...
Define *T.IntegerArray ; Seul obligation : bien préciser une structure définissant un tableau en son  contenu
Debug *T
Debug "(Si c'est nul, Selzig peut mettre 'Résolu' à son problème ! )"

Debug "Continuons... Pour rester constructif !"

*T = AllocateMemory(SizeOf(ArrayInteger) )
Debug *T ; pointe vers un tableau ABSOLUMENT VIDE

InitializeStructure(*T, IntegerArray)
Debug *T ; normalement inchangé MAIS pointe vers un tableau ayant une valeur entière en index 0

; Ecrivons dans ce tableau...
*T\Value(0) = 99

;Affichons...
Debug *T\Value(0)

; "Amusons"-nous : redéfinissons la taille du tableau sans effacement des données...

Redim *T\Value(1 << 23) ; Allez hop ! Tableau de...
; 64 méga en 32 bits
; et 128 méga en 64 bits

Debug "Si 99, alors redimensionnement sans effacement ok : " + Str(*T\Value(0) )

*T\Value($FFFFFF) = 101 ; dalmatiens...

debug "Nombre de dalmatiens... " + Str(*T\Value($FFFFFF) )

; Un petit redimensionnement avec effacement...
Dim *T\Value(2)

; Un déguelingage de tableau
ClearStructure(*T, IntegerArray)

;Huheup!! On n'est pas satisfait : on est sceptique sur l'efficacité du déguelingage. On va vérifier autrement...

;Soyons fous : libérons de la mémoire qui risquerait de ne pas en libérer, étant donné qu'on est sceptique...
FreeMemory(*T)

; Et passons à la méthode "Fred te prend par la main..." ....

AllocateStructure(*T, IntegerArray)

; Allouons 1 gigaoctet... (ou 2 selon mode 32/64 bits)
Dim *T\Value($7ffFFff)
*T\Value($7ffFFff) = 103 ; comme l'un des préfixes des instructions 16 bits...
... ou comme la Peugeot !

MessageResquester(Str(*T\Value($7ffFFff) ), "Regarde tes ressources en mémoire...")

ClearStructure(*T, IntegerArray)

MessageResquester("", "Regarde une 2ème fois tes ressources en mémoire...")

InitializeStructure(*T, IntegerArray)
Dim *T\Value($7ffFFff)

MessageResquester("Montagnes russes", "Regarde une 3ème fois tes ressources en mémoire...")

FreeStructure(*T, IntegerArray)

*T = 'Hu??'
; ici, je me sers du pointeur de tableau pour faire n'importe nawak, je ne gaspillerai rien
; en tout cas, *T\Value(0) n'existe pas

MessageResquester("Montagnes russes", "Regarde une 4ème fois tes ressources en mémoire...")

; Allez une dernière pour la route...
AllocateStructure(*T, IntegerArray)
Dim *T\Value(1 << 27) ; Toujours 1 à 2 Gigots selon 32/64 machins

ClearStructure(*T, IntegerArray)
FreeMemory(*T)

Maintenant, rien ne t'empêche de nicher tes tableaux dans CE tableau *T. Je peux t'assurer qu'il ne restera pas un octet même avec tableaux de chaînes.