PureBasic

Tout à fait. Le pointeur est un entier.

Define *Pointeur
Define Pointeur.I     ; Un entier : (I)nteger

Même fonctionnement, même résultat. Tout est en mémoire, donc tout est pointé ("adressé").

L'astérisque c'est juste pour que le programmeur dicerne facilement les pointeurs des variables classiques dans son code source. Car un pointeur mal fixé, c'est un crash du programme (heureusement très bien géré par le débogueur natif).

Une constante, une variable (pointeur ou non), un tableau ou une procédure ont tous un pointeur.
Les listes et maps en ont aussi mais 'par élément'. C'est-à-dire que c'est chaque élément qui se décrit par un pointeur.

Le mieux c'est, effectivement, à l'instar de ta procédure LectureMemoire() faire une procédure (c'est possible en macros aussi, mais au plus simple d'abord!) pour chaque action intéressante:

MapCreer()
MapSupprimer()

ListeCreer()
ListeSupprimer()

etc...

Sans macro, c'est encore lourd, mais déjà, le concept prend forme.

Un détail important: si tu veux éviter quelques gamelles EnableExplicit t'impose de prévenir le compilateur de telle ou telle nouvelle variable.

Mon conseil utilise-le! Et dès que tu as une erreur à cause d'EnableExplicit, par exemple NombreMap.I est 'clandestin', tu l'as utilisé dans un calcul directement sans prévenir avant.

Dans ce cas, pour l'instant, déclare une variable ainsi:

Code : Tout sélectionner

Global NombreMap.I
Global NombreListe.I

Etc...
Ça évite de se poser sur la considération d'une variable à tel ou tel endroit du programme. Là, avec Global TaVariable, ta variable est une star connue dans tout le programme sans se poser de questions.

Salut,

Très intéressant tous se que tu me raconte là dis moi

Je suis notamment intéresser pour savoir comment je peut faire pour récupérer chaque élément d'une liste, tableau et map, leur pointeur comme tu dis.

Peut être que je dois parcourir chaque élément et stoker le pointeur de chaque élément dans une liste ou quelque chose du style ?
Peut être comme ça t'en pense quoi ?:

Code : Tout sélectionner

Dim MonTableauDePointeur.i(10)
Dim MonTableau.s(10)

For Index = 0 To 10
  MonTableau.s(Index) = "Index n°" + Str(Index)
  MonTableauDePointeur.i(Index) = @MonTableau.s(Index)
Next

For Index = 0 To 10
  Debug "Le pointeur de MonTableau à la position " + Str(Index) + " = " + Str(MonTableauDePointeur.i(Index)) + ", Il contient le texte suivant: " + Chr(34) + PeekS(MonTableauDePointeur.i(Index)) + Chr(34)
Next

Pour EnableExplicit, je suis bien d'accord avec toi, combien de fois j'ai pue passer des siècles à déboguer un fichu code à cause d'une simple variable XD.
Peut tu me donner plus de détail sur le code plus haut, avec le système de la structure dans le pointeur, j'ai pas compris comment ça marchait en faite.

Merci.

C'est très bien ton double tableau. Tu rajoutes un 3ème tableau, pour les types et tu auras déjà un "noyau de données" compréhensible. Je vais poster un code de suggestion un peu plus tard (pas trop!).

Il est à noter que ce double tableau peut-être simplifié à une map.

Code : Tout sélectionner

Global Newmap *Pointeur()

Define X.I = 50
*Pointeur("X") = @X

Debug X
Debug PeekI(*Pointeur("X") )

Pour les structures, ça peut s'apparenter à un panneau de situation autour d'un rond-point, ou d'un carrefour.

Tu as un poteau: c'est le pointeur.
Puis tu as un 1er panneau "Centre-ville" sur fond blanc.
Puis tu as un 2nd panneau:

Le 2nd panneau a écrit :Calais
Fribourg
Dresde

sur fond vert. Bon, là tu sais que les 3 bleds ce sera par des routes nationales.
Puis, plus haut encore, sur le même poteau, tu as un 3ème panneau...

... qui a écrit :PARIS
NEW-YORK

sur fond bleu. Là, tu sais, d'instinct que c'est par l'Autoroute que tu vas atteindre ces 2 autres destinations. (Note: realimse zéro, mais c'est pas grave, c'est pour l'explication...)

Une structure en informatique, c'est un peu comme ces panneaux.
Ça part d'un poteau, puis tu as des éléments plus ou moins regroupables par des critères de ton choix.
Chaque élément est très facilement amovible, ce qui fait gagner du temps de programmation par rapport à ma méthode à l'ancienne, avec des tableaux.

Si tu bouges le poteau (= si tu modifies le pointeur), tu embarques toutes les infos de structure avec toi. Par contre, tu n'effaces pas les données qui y étaient.

Ainsi, pour "traduire", il faut peu pour rajouter les kilomètres pour chaque destination. Pas sûr du tout que cela soit simple avec de simples tableaux si, soudain, il te prend l'idée de placer des structures DANS les structures.

Exemple concret avec un peu de biologie pour changer:

(note : ça se lit de bas en haut)

Code : Tout sélectionner

Structure PIF
Nom.S
TauxO2.D
TauxCO2.D
TauxCO.D
EndStructure

Structure MAIN
   Pouce.PIF
   Index.PIF
   Majeur.PIF
   Annulaire.PIF
   Auriculaire.PIF
EndStructure

Structure GAUCHE
   Main.MAIN
EndStructure

Structure DROITE
   Main.MAIN
EndStructure

Structure TRONC
   Gauche.GAUCHE
   Droite.DROITE
EndStructure

Ça, ça te met un jeu (PIF) de taux gazeux par doigt pour 2 côtés (gauche et droite). C'est un gabarit de structure. Il n'y a aucune donnée de placée à ce moment.

'Define', c'est similaire à Global, mais en moins bourrin. Les variables définies par 'Define' ne sont pas visibles au sein des procédures.

Ce code "à l'ancienne" permet d'accumuler une collection d'objets entiers. Tu peux tester pour rajouter un autre type de variables.

Ce qui est intéressant aussi, c'est la macro juste après les procédures. Sur le plan visuel, ça ressemble un peu à une procédure.

Ce bout de macro, est une prise d'information. Que tu travailles avec ou sans structure, cette macro sera nécessaire pour surveiller une déclaration de variable.

Code : Tout sélectionner

 EnableExplicit

Macro Guillemet:"
EndMacro

#ObjetTypeInconnu = 0
#ObjetTypeEntier  = 1

Global CollectionReelle.I = 0
Global CollectionQuantite.I = 100
Global CollectionMaximum.I = 4000

Global ObjetMaximum.I
Global ObjetNouveau.I

Global Dim ObjetNom.S(0)
Global Dim ObjetType.I(0)
Global Dim ObjetAdresse.I(0)

; A partir d'ici, les noms de procedures
; se lisent plus facilement de bas en haut.
; Pour eviter ce type de contrainte de programmation,
; il existe la directive 'Declare'.
; Dans ce cas, on met la procedure ou l'on veut
; dans le programme tant qu'elle se situe
; apres sa declaration.

Procedure Sortie(Message.S)
	Debug Message
EndProcedure

Procedure CollectionAjourner()
	ObjetMaximum = CollectionQuantite - 1
	ReDim ObjetNom.S(ObjetMaximum)
	ReDim ObjetType.I(ObjetMaximum)
	ReDim ObjetAdresse.I(ObjetMaximum)
EndProcedure

Procedure CollectionAugmenter()
	CollectionQuantite * 2
	CollectionAjourner()
EndProcedure

Procedure CollectionDiminuer()
	CollectionQuantite / 2
	CollectionAjourner()
EndProcedure

Procedure ObjetAvertissement(Message.S)
	MessageRequester("Avertissement", Message)
EndProcedure

Procedure ObjetAlerte(Message.S)
	ObjetAvertissement(Message + Chr(10) + Chr(10) + "Cliquer sur [Ok] pour terminer")
	End
EndProcedure

Procedure ObjetSuivant()
	Protected FinDeTableauAtteinte.I		
	Repeat		
		ObjetNouveau + 1
		If ObjetNouveau > ObjetMaximum
			If FinDeTableauAtteinte
				ObjetAlerte("Tableaux satures !")
			Else
				ObjetNouveau = 0
				FinDeTableauAtteinte = #True
			EndIf
		EndIf
	Until ObjetType(ObjetNouveau) = #ObjetTypeInconnu
EndProcedure

Procedure ObjetCreer(Numero.I, Nom.S, Type.I, *Adresse)
	If ObjetType(Numero) = #ObjetTypeInconnu
		If Type <> #ObjetTypeInconnu
			ObjetNom(Numero) = Nom
			ObjetType(Numero) = Type
			ObjetAdresse(Numero) = *Adresse
			CollectionReelle + 1
		EndIf
	EndIf
EndProcedure

Procedure ObjetAjouter(Nom.S, Type.I, *Adresse)
	ObjetCreer(ObjetNouveau, Nom, Type, *Adresse)
	ObjetSuivant()
EndProcedure



Procedure ObjetSupprimer(Numero)
	If ObjetType(Numero) <> #ObjetTypeInconnu
		CollectionReelle - 1
		ObjetType(Numero) = #ObjetTypeInconnu
	EndIf
EndProcedure

Procedure CollectionMontrer()
	Sortie("Nombre d'objet(s) : " + Str(CollectionReelle) )
EndProcedure


Macro Definit(SonNom, SonType)
	Define SonNom.SonType
	CompilerIf (Guillemet#SonType#Guillemet = "I") Or (Guillemet#SonType#Guillemet = "i")
		ObjetAjouter(Guillemet#SonNom#Guillemet, #ObjetTypeEntier, @SonNom)
	CompilerEndIf
EndMacro

; Code principal
CollectionAjourner() ; = mettre a jour
Definit(X, I)
X = 10
CollectionMontrer()
; Fin de code principal

CompilerIf
et
CompilerEndIf

pt de vue programmation, c'est à peu près la même que If...EndIf.

CompilerIf est une directive, non pas une instruction. Comparaison.

CompilerIf est testé à la compilation de l'EXE, pas à l'exécution.
CompilerIf va donc être plus rapide, même si ce n'est pas simplement comparable.
CompilerIf interdit tout sauf des constantes.
CompilerIf dans une macro se moque de la forme de l'objet que l'on teste, tant que cette objet est l'attribut d'une directive ou une constante, et tant qu'on la coffre dans une chaîne entre guillemets. C'est la raison même du trifouilli que tu vois après CompilerIf.

La réalité c'est que je lui demande de me vérifier quel type a été utilisé dans la définition.

Là, j'ai 'shunté' la directive 'Define' par la macro 'Definit'.

Résultat, au lieu de faire une simple définition de variable, on a cette définition + un enregistrement de la variable.

Revenons à l'essentiel (n'hésite pas quand même pour des questions évidemment)

Pour recenser une variable, son type, et sa visibilité dans le code, on shunte les directives qui les définissent.

Coup de chance: c'est la même syntaxe.
Pour définir par exemple un nombre flottant double précision, c'est:

Define Nombre.D ; D c'est le type (cf doc)
Global Nombre.D

Protected Nombre.D
Shared Nombre.D
Static Nombre.D

Define définit une variable visible hors des procédures.

Global définit une variable visible partout.

Protected c'est l'équivalent de Define mais pour définir une variable éphémère dans une procédure (la valeur de la variable est toujours nulle au départ de la procédure).

Static c'est comme protected mais pour définir une variable persistante au sein d'une procédure (pas de RAZéro au sortir de la procédure).

Shared c'est pour aller choper, depuis une procédure une variable hors d'une procédure.

Il faut donc déjà 5 macros qui ressemblent à 'Definit()' pour récolter les infos sur les variables.

Pour les listes et maps, ce sont juste des types supplémentaires à créer, et les adresses de chaque élément sont accessibles de 2 manières (c'est pour ça que tu me vois expliquer avec 2 versions: à l'ancienne, ou moderne, plus concrètement et respectivement, sans structure ou avec structure)

Sans structure: (à l'ancienne)

Code : Tout sélectionner

NewList L.I()
NewMap M.I()

AddElement(L() )
L() = 10
Debug "Adresse élément liste : " + @L()

M("MaClef") = 25
Debug "Adresse élément map : " + @M("MaClef")

Avec structure: (moderne)

Code : Tout sélectionner

NewList L.INTEGER()
NewMap M.INTEGER()

AddElement(L() )
L()\I = 10
Debug "Adresse élément liste : " + L()

M("MaClef")\I = 25
Debug "Adresse élément map : " + M("MaClef")

En espérant que ce jeu des 6 différences t'apportent des indices suffisant pour passer d'une méthode à l'autre...

Alors, ce qui importe avec la structure plus haut, copiée ci-dessous et modifiée pour explication (c'est la structure au PIF qui subit un changement), c'est l'image arborescente que l'on peut s'imaginer.

Aussi, les taux gazeux mesurés sur chaque doigt, c'est trop redondant (on obtient bien plus que des doublons de valeurs). Avec ça, d'autres informations peuvent être intéressantes. En modifiant la structure par l'ajout d'une union, le programmeur peut ensuite choisir pour chaque doigt, quel outil de mesure sera utilisé (mesure de taux gazeux ou alors thermomètre par exemple).

Code : Tout sélectionner

Structure TAUX
   TauxO2.D
   TauxCO2.D
   TauxCO.D    
EndStructure
Structure PIF
   Nom.S
   StructureUnion
      Taux.TAUX
      Temperature.F
   EndStructureUnion
EndStructure
Structure MAIN
   Pouce.PIF
   Index.PIF
   Majeur.PIF
   Annulaire.PIF
   Auriculaire.PIF
EndStructure
Structure GAUCHE
   Main.MAIN
EndStructure
Structure DROITE
   Main.MAIN
EndStructure
Structure TRONC
   Gauche.GAUCHE
   Droite.DROITE
EndStructure

Un exemple plus simple:

Code : Tout sélectionner

Structure Nombre32bits
   Type.I
   StructureUnion
      Entier.L
      Flottant.F
   EndStructureUnion
EndStructure

Define p.Nombre32bits

p\Entier = 5
p\Flottant = 2.5 ; Ecrase la valeur 5 en mémoire

Debug p\Entier ; Valeur 'buguée'
Debug p\Flottant ; Valeur 2.5

Note : C'est en voyant l'impossibilité de savoir quel champs dans l'union (Entier ou Flottant) a été utilisé que l'on comprend l'utilité du champs 'Type'.

Suite à info de Micoute, la nature de la macro 'Definit()' peut être simplifiée!

Je pensais que TypeOf() ne servait que pour déterminer les types de champs de structure...

Bonjour Ollivier et encore merci de ton aide...

Tous cela est encore trop pointu pour moi, mais j'vé m’accrocher.
Allons-y doucement stp et merci de t'es explication qui sont simple je trouve

PureBasic

Comment récupérer valeur variable, tableaux, liste, map...

Re: Comment récupérer valeur variable, tableaux, liste, map.

Re: Comment récupérer valeur variable, tableaux, liste, map.

Re: Comment récupérer valeur variable, tableaux, liste, map.

Re: Comment récupérer valeur variable, tableaux, liste, map.

Re: Comment récupérer valeur variable, tableaux, liste, map.

Re: Comment récupérer valeur variable, tableaux, liste, map.

Re: Comment récupérer valeur variable, tableaux, liste, map.

Re: Comment récupérer valeur variable, tableaux, liste, map.

Re: Comment récupérer valeur variable, tableaux, liste, map.