ReDim pour toute les dimensons Redim Table$(va1,10,var2)

[GeBonet]

Bonjour,

PureBasic permet de redimensionner la dernière dimension d'un tableau Table$(10,variable)...

Ce qui me pose problème c'est que dans un tableau tel que :
Table$(NbrLigne, NbrColonne) je puisse pas modifier le nombre de ligne...

Car si c'est le nombre de ligne qui est sujet à augmenter alors cela m'oblige à écrire mon tableau comme ceci :
Table$(NbrColonne, NbrLigne) afin de pouvoir utiliser ReDim pour la variable NbrLigne qui est alors la dernière... c'est à dire faire faire un quart de tour à mon tableau...

Alors que mes colonne étaient (Nom, Prénom, adresse,..., Email,Etc.)
Ce serait déjà mieux de pouvoir redimensionner un des deux et pas seulement la dernière... Et ce serait mieux d'avoir mes libéllé en tête de colonne et mes lignes comptant mes enregistrement... non ?

Bon, après l'avoir Redimensionné, je peux toujours le remettre dans l'état de départ... Mais ça fait du code... pour un simple ReDim ?

Mais allons plus loin, si je veux faire un tableau qui serait en liaison avec des fichiers... 1, 2, n Je devrais avoir un tableau sous cette forme :

Table$(N°Fichier1,NbrLigne, NbrColonne)
Et cela devrait pouvoir être un peu plus dynamique... C'est à dire pas seulement "NbrColonne"
Mais au moins le nombre de ligne ou qu'il se trouve...

Qu'en pensez vous ?

[Anonyme]

un peu désuet la dim(x,x,x) non ?
le top c'est les structures dans ton cas , non ?

[Backup]

carrement !!

les structures + linked list !!

ya pas plus simple

(heu !! c'est moi qui parle la ?? .... vos gueules les anciens )

ya un bon tuto sur les structures sur le forum !!

cependant si t'a des questions sur le sujet, n'hesite pas

[Backup]

voici la base des structures en reprenant ton exemple


j'ai cree 2 procedures pour te montrer combien c'est facile

une qui cree un enregistrement
une autre qui te cree une recherche en fonction du nom

Code : Tout sélectionner

; on cree une structure table
; qui contient 3 elements
Structure table
        nom$
        prenom$
        adresse$ 
EndStructure

Global NewList table.table() ; on dimensionne notre structure avec une liste chainée



Procedure ajout_record(nom$,prenom$,adresse$)
        AddElement(table())
        table()\nom$=nom$
        table()\prenom$=prenom$
        table()\adresse$=adresse$ 
EndProcedure

Procedure.s recherche_element(nom$)
        ForEach table()
                If table()\nom$=nom$
                        Break
                EndIf 
        Next
        retour$=table()\nom$+","+table()\prenom$+","+table()\adresse$
        ProcedureReturn retour$
EndProcedure





; ************ voila pour ajouter un enregistrement  tu fait ****************
nom$="toto"
prenom$="titi"
adresse$="20 rue de la paix"


ajout_record(nom$,prenom$,adresse$)

; ***************************************

; pour une recherche d'info tu fait :

auteur$="toto"
info$=recherche_element(nom$)
 
Debug "premier champ= "+ StringField(info$,1,",")
Debug "deuxieme champ= "+ StringField(info$,2,",")
Debug "troisieme champ= "+ StringField(info$,3,",")

gros avantage , tu peux creer autant d'enregistrement que tu as de Ram !!
t'es plus limité par un dim(x,x)

tu peux suprimer un enregistrement tres facilement sans que cela ne foute le bazard dans les autres

pour t'avouer, mon langage "le pureGolo" qui va bientot ressortir de sa boite
est basé sur ce principe , et c'est beton !!

[GeBonet]

Déjà merci,
Rapide comme d'habitude...
Plus des solutions...
Et effectivement les dim(x,x,x) c'est probablement désuet... comme moi d'ailleurs
Mais j'ai des formes de structures entières de quelques milliers de lignes qui reposent sur des table$(x,x,x) et un ISAM maison qui s'en accommoderait bien... Que j'aurais quand même aimé récupérer sans trop "repenser" !

Mais l'objet de la rubrique n'est pas le seul intérêt personnel !

Donc au delà de ça, je me disais que puisque ReDim existe déjà,
alors ce serait bien de ne pas être limité par le dernier des deux.... Et c'est tout !

Et cela évidement indépendamment des avantages que représentent les Structures qui existaient aussi dans QBX...
Doublé ici des listes chainée... Que j'étudie attentivement...

Mais je n'ai pas encore trouvé comment remplacer un ensemble totalement paramétrable et variable sans utiliser des table$()... et des fichier style ".pref". Mais mes neurones sont ramollis...

L'objet pour moi en fait n'est pas de créer des fichiers fixes ou une application, mais de donner à un utilisateur le loisir de créer lui même une application à partir de fiche qu'il créerais dans un environnement style "PureFORM" un peu plus étendus aux fichiers sous jacents et des relations qu'ils auraient entre eux... Et les fenêtres qui vont avec bien évidement. Soit ce que j'ai déjà crée sous Dos, il y a très longtemps. Et rangeait dans des tables les exigences de l'utilisateur.
Le tout sans utiliser de langage s'entend du moins comme vous et moi l'entendons. Ce serait en fait une espèce d'interpréteur de macro commandes. Ou comment recréer sous PB et environnement graphique de ce qui existait sous DOS.

Mais bon, c'est pas très important, je passe mon temps.

Maintenant il y a une autre option pour arriver à cela, et qui serait de continuer ce que fait "PureForm", en créant un "PureFICH" qui créerais la suite du code crée par PureFORM et utile à la gestion des fichiers qui vont avec... On aurais alors un "Générateur" de "Code"... Et qui serait peut-être plus en phase avec ce qui se fait aujourd'hui.

Une application de ce genre complèterais PB puisque serais une outil de création en gestion de donnée assez rapidement utilisable sans connaissance approfondie... Le genre d'application "Livre" faite par Comtois pour s'exercer au Sqlite, avec ce genre d'outil devrait se créer en 1 heure max...

Faute de solution, v'la p'têtre une idée à creuser ?

Bon, bon, ça, va... Je vais étudier les listes chainées... Grondez pas !

[Backup]

pour te resumer le principe des liste chainée en 3 mots !!

c'est une pile !!

un long tube , dans lequel tu ajoute des valeurs les une apres les autres
et ses valeurs (qui peuvent etre aussi des chaines de caracteres) , s'entasse dans la liste

d'ou le nom


dans mon interpreteur logo (pureGolo) , j'utilise une liste chainée comme pile de prg !!

ensuite tu as une commande pour deplacer un pointeur , qui va pointer une valeur se trouvant dans la liste

on peut ajouter une valeur, l'effacer , la swapper avec une autre , etc ...

c'est tres pratique , mais ça force a penser en une seule dimension !!

donc si tu entasse des blocs de données par 10

il faudra quater de 10 en 10 pour atteindre la debut de chacun de tes blocs de données

c'est assez simple en faite !

avant j'etais tres tableau Dim()
mais je dois dire que ma conversion est quasi total !!

je dit quasi, parcequ'il m'arrive par reflexe de recourir au tableau dim()
pour des petits projet