variables @ et variables *

Hableur · Message par **Hableur** » jeu. 14/sept./2006 9:49

Bonjour,

Dans les scripts de ce forum, on voit différentes syntaxes de variables dont, malgré la lecture du manuel en ligne, je n'ai pas bien compris la signification.

A savoir:

variable ;-> valeur de la variable

@variable ;-> adresse de la variable

*variable ;-> ????????????????????????

D'autre part, on trouve l'utilisation de

variable$ ;-> Est-ce équivalent à variable.s ?

Merci

Progi1984 · Message par **Progi1984** » jeu. 14/sept./2006 9:56

*varaible -> pointeur de mémoire d'une variable
.
.
.
.
.
.
.
.
si j'ai bien appris mes lecons.

Hableur · Message par **Hableur** » jeu. 14/sept./2006 14:38

Mais alors quelle différence entre @variable et *variable ?

Et un autre truc que je n'ai pas trouvé dans le manuel.

Quelle différence entre une constante et une variable ?

Si je tape: #base_donnee=1

ou si je tape: base_donnee.b=1

qu'est-ce que ça change ?

Progi1984 · Message par **Progi1984** » jeu. 14/sept./2006 15:52

Quelle différence entre une constante et une variable ?
Une constante est une variable dont le contenu ne peut varier et reste donc constante

Une constante est une variable dont le contenu peut varier

Quelle différence entre @variable et *variable ?
J'utilise @variable surtout dans le cas variable est un string afin de faire des peeks et autres pokes.
et *varaible pour travailler en direct sur la mémoire alloué à la variable.

KarLKoX · Message par **KarLKoX** » jeu. 14/sept./2006 16:45

* --> pointeur
@ --> adresse mémoire
@* --> adresse mémoire du pointeur

Hableur · Message par **Hableur** » jeu. 14/sept./2006 16:59

Merci pour ta réponse.

Pour les constantes, j'ai compris que la valeur qui leur est allouée en début de script ne peut plus être modifiée.

Pour *variable, ça m'échappe. D'ailleurs les deux scripts suivants donnent les mêmes résultats.

Code : Tout sélectionner

Structure astruct
       b.l
EndStructure
  
  Procedure SetB(monpointeur.astruct)
    monpointeur\b = 69
  EndProcedure
  
  mavariable.astruct 
  mavariable\b = 0
  SetB( @mavariable )
  Debug mavariable\b
  End

et

Code : Tout sélectionner

Structure astruct
     b.l
   EndStructure
  
  Procedure SetB(*monpointeur.astruct)
    *monpointeur\b = 69
  EndProcedure
  
  mavariable.astruct 
  mavariable\b = 0
  SetB( @mavariable )
  Debug mavariable\b
  End

Donc j'en conclus que c'est pas trop la peine que je me casse la tête

comtois · Message par **comtois** » jeu. 14/sept./2006 17:08

Hableur a écrit :Quelle différence entre une constante et une variable ?

La différence c'est que le compilateur va remplacer ta constante directement par sa valeur dans le code ASM, alors que pour la variable ça sera son adresse.
De même qu'un calcul simple par exemple a = 4 + 5 , le compilo écrira a = 9 dans le code ( , il prendra directement le résultat de l'addition, autrement dit le compilo t'évite une addition dans ton code)

Ce code ne fonctionne pas, j'ai une syntax error ! , par contre ton deuxième code est correct .

Code : Tout sélectionner

Structure astruct
       b.l
EndStructure
 
  Procedure SetB(monpointeur.astruct)
    monpointeur\b = 69
  EndProcedure
 
  mavariable.astruct
  mavariable\b = 0
  SetB( @mavariable )
  Debug mavariable\b
  End

Hableur · Message par **Hableur** » jeu. 14/sept./2006 18:42

La différence c'est que le compilateur va remplacer ta constante directement par sa valeur dans le code ASM, alors que pour la variable ça sera son adresse.

Yesss, là je comprends.

Ce code ne fonctionne pas, j'ai une syntax error ! , par contre ton deuxième code est correct .

Et bé oui, tu as raison, je ne sais pas comment j'ai fait mon compte, pourtant j'avais testé les deux. J'ai du faire run après avoir supprimé les * au lieu de compiler

Donc *variable permet de faire passer des objets comme des structures aux procédures. Mais *variable donne quoi ? Pas l'adresse de variable, puisque c'est @variable...

L'adresse du pointeur pointé sur l'objet ? Je ne comprends même pas le sens de ma phrase

En tout cas, merci pour votre patience les gars

Flype · Message par **Flype** » jeu. 14/sept./2006 18:51

Hableur a écrit :
La différence c'est que le compilateur va remplacer ta constante directement par sa valeur dans le code ASM, alors que pour la variable ça sera son adresse.
Yesss, là je comprends.

En fait une constante c'est comme une macro.
D'ailleurs en C, la définition d'une constante ressemble à s'y méprendre à la définition d'une macro.

Flype · Message par **Flype** » jeu. 14/sept./2006 19:01

Hableur a écrit :
Donc *variable permet de faire passer des objets comme des structures aux procédures. Mais *variable donne quoi ? Pas l'adresse de variable, puisque c'est @variable...

L'adresse du pointeur pointé sur l'objet ? Je ne comprends même pas le sens de ma phrase

en fait 'variable' et '*variable' n'ont que très peu de différence.

je vais tenter de t'expliquer :

'variable' est en fait 'variable.l' - un long de 32 bit.

'*variable' n'est pas 'variable.l', c'est un type pointeur qui sur une machine 32 bit sera un long de 32 bit mais sur une machine 64 bit '*variable' sera de la taille d'adressage du proc donc 64 bit. sauf que pour l'instant, purebasic n'est pas 64 bit ready.

Le '*' permet aussi de mieux se repérer, de mieux typer ces variables.
Le programmateur désireux de faire les choses bien cherchent toujours à typer correctement ce qu'il utilise.

regarde ce mini code :

Code : Tout sélectionner


Variable.l = 12345

*Variable = @Variable

Debug PeekL(*Variable)

je déclare une variable qui a la valeur 12345 de type long grace à '.l'

je récupère l'adresse mémoire de ma variable grace à '@'

je stocke cette adresse mémoire dans une variable de type pointeur.

je lis la valeur stockée dans le pointeur.

Par ailleurs et pour aller plus loin, '*Variable' ouvre un nouveau monde par rapport à 'Variable'.
En effet typer mon pointeur avec un '*' permet de lui attribuer une structure.

dans l'example suivant, je décide que '*Variable' soit structuré de telle façon que je n'aurais plus besoin d'utiliser PeekL().

en sachant que le type .Long est défini comme suit :

Structure Long
l.l
EndStructure

Code : Tout sélectionner

Variable.l = 12345

*Variable.Long = @Variable

Debug Variable
Debug *Variable\l

Hableur · Message par **Hableur** » jeu. 14/sept./2006 19:02

Bon en fait, *variable est le pointeur pointé sur @variable.

@variable est l'adresse, et *variable la machine qui travaille dessus.
C'est mieux ça ?

Hableur · Message par **Hableur** » jeu. 14/sept./2006 19:27

Flype a écrit :
Hableur a écrit :
Donc *variable permet de faire passer des objets comme des structures aux procédures. Mais *variable donne quoi ? Pas l'adresse de variable, puisque c'est @variable...

L'adresse du pointeur pointé sur l'objet ? Je ne comprends même pas le sens de ma phrase
en fait 'variable' et '*variable' n'ont que très peu de différence.

je vais tenter de t'expliquer :

'variable' est en fait 'variable.l' - un long de 32 bit.

'*variable' n'est pas 'variable.l', c'est un type pointeur qui sur une machine 32 bit sera un long de 32 bit mais sur une machine 64 bit '*variable' sera de la taille d'adressage du proc donc 64 bit. sauf que pour l'instant, purebasic n'est pas 64 bit ready.

Le '*' permet aussi de mieux se repérer, de mieux typer ces variables.
Le programmateur désireux de faire les choses bien cherchent toujours à typer correctement ce qu'il utilise.

regarde ce mini code :
Code : Tout sélectionner
Variable.l = 12345

*Variable = @Variable

Debug PeekL(*Variable)
je déclare une variable qui a la valeur 12345 de type long grace à '.l'

je récupère l'adresse mémoire de ma variable grace à '@'

je stocke cette adresse mémoire dans une variable de type pointeur.

je lis la valeur stockée dans le pointeur.

Par ailleurs et pour aller plus loin, '*Variable' ouvre un nouveau monde par rapport à 'Variable'.
En effet typer mon pointeur avec un '*' permet de lui attribuer une structure.

dans l'example suivant, je décide que '*Variable' soit structuré de telle façon que je n'aurais plus besoin d'utiliser PeekL().

en sachant que le type .Long est défini comme suit :

Structure Long
l.l
EndStructure
Code : Tout sélectionner
Variable.l = 12345

*Variable.Long = @Variable

Debug Variable
Debug *Variable\l

Là je crois avoir compris, mais seulement quand j'ai voulu éditer une réponse en te citant car curieusement, tout ton texte initial n'apparaît pas dans le forum !

Etonnant, non ?

Hableur · Message par **Hableur** » jeu. 14/sept./2006 19:30

Ah ben si maintenant, tout ton texte apparaît. Scusez, j'ai eu un truc bizarre...

Flype · Message par **Flype** » jeu. 14/sept./2006 19:34

ca doit etre de ma faute - j'ai modifié mon post en meme temps que tu me répondais.

Dräc · Message par **Dräc** » mar. 19/sept./2006 23:54

Hableur a écrit :Bon en fait, *variable est le pointeur pointé sur @variable.

@variable est l'adresse, et *variable la machine qui travaille dessus.
C'est mieux ça ?

Je pense que tu l'auras compris avec les explications de Flype, en Purebasic, variable et *variable sont deux entités disteinctes. L'une comme l'autre peuvent exister indépendamment: le fait que leurs noms comportent le mot "variable" ne les lies pas entre elles car le * fait parti intégrante du nom d'un pointeur.

Ensuite pour préciser, au risque d'irriter Flype qui est programmeur professionnel et donc maitrise trés bien ces choses là

:
- on ne type pas un pointeur, on type une variable. Mettre * devant une variable indique qu'il s'agit d'une variable de "type pointeur" dont la taille mémoire dépend de la capacité d'adressage de la machine comme le rappelle Flype.
- les pointeurs ne sont pas les seules variables à pouvoir etre structurées. Toutes les variables le peuvent (hors constantes qui sont typées par leurs contenus)
Par contre, les pointeurs sont trés utiles s'ils sont structurés et l'exemple de Flype le montre parfaitement.

Je ne peux que te conseiller la doc "nouvelle formule" mise à jour par Comtois qui reprend ces notions au sujet des pointeurs:
http://purebasic.forum-gratuit.com/view ... highlight=