variable scope

[Marc56]

À vrai dire c'est le mot "Shared" (partagé) qui trompe.
De ce que j'ai testé et compris (?), "Shared" dans une procédure permet l'accès depuis une procédure à une variable non-globale.
(Ce qui correspond bien à l'aide "Shared permet de rendre une variable, un tableau, une liste ou une map non global accessible depuis une procédure.")
Ça se voit en mettant l'indispensable EnableExplicite

Testez ceci:

Code : Tout sélectionner

EnableExplicit

Define a = 10

Procedure Change()
     Shared a
     a + 20 
EndProcedure 

Debug a
Change()
Debug a 

Ensuite, mettez un ; devant Shared
Ligne 7: Avec 'EnableExplicit', les variables doivent etre explicitement declarees: a

On voit donc bien que "Shared a" a accédé à "a" qu'il ne pouvait pas voir puisque hors procédure et non global

[Zorro]

en fait Shared permet a une variable locale a une procedure
d'être partagé en dehors de la procedure

Code : Tout sélectionner

calldebugger

Procedure P()
		Variable_non_partage=10
endprocedure


Procedure P2()
		Shared   Variable_partage
		Variable_partage=20
endprocedure



P()
debug Variable_non_partage ; renvoi 0


P2()
debug Variable_partage ; renvoi 20 car cette variable est partagée

[djes]

Oui, je n'aurais pas dû faire de généralités, même s'il n'y a pas de BASIC «traditionnel» comme tu le dis,

c'est pourquoi j'ai mis entre guillemets !

Je rappelle quand même pour faire avancer le schmilblick qu'il ne s'agit pas de variables, mais de paramètres. Ce n'est pas tout à fait la même chose, perso je fais la distinction et je vous encourage à le faire, même si ça ne va pas changer le monde...

on parle bien de variables ... qui se trouve dans la procedure ...
le parametres c'est une variable qu'on passe en parametre (par les parentheses) de la fonction ... on va pas jouer sur les mots ..

et que je n'ai pas le courage d'aller voir les quelques versions normalisées ANSI et autres pour te contredire

ben j'ai recherché pour toi

en VisualBasic

1.2 Portée des variables
L’existence d’une variable peut se dérouler sur trois niveaux :
Niveau Procédure : cela veut dire que la variable est locale. Dès que l’on quitte la procédure en question, la variable disparaît, et son contenu avec elle.

en GFABAsic , il fallait preciser qu'une variable etait Local , avec la directive "Local"

exemple : (ici en GFABasic 32 bits )

Code : Tout sélectionner

Proc WndProc(hWnd As Handle, msg As Int, _
  wParam As Int, lParam As Int) Naked
  Local RetVal
  '... Code ...
  Asm mov eax, [RetVal]
EndProc

en BlitzBasic 3D
les variable dans les procedures sont automatiquement en Local exemple :

Code : Tout sélectionner

function Machin()
  var#=9.0
end function
print Var => affichera '0.0'

en DarkBasic Pro , page 31 du manuel il est ecrit

Les variables et tableau sont idépendants du reste du programme
Ainsi, une variable FRED dans une fonction n'affectera pas une autre variable FRED
qui serai déclaré dans le programme principal ni
qui serai déclarée dans une autre fonction .....

en OMIKRON Basic

On peut définir des variables locales par LOCAL V$=, W$=, qui n'interféreront pas avec les variables globales de même nom,

je ne parlerai bien sur pas des anciens basic, qui ne geraient pas le concept de fonctions (procedures)
je pense au ZX81 Basic (basic Spaghettis a base de Goto )

mais pour ma part mis a part quelques uns (rare) ou il faut preciser qu'une variable est Local dans une procedure (GFA Basic , L'Omikron ; et d'une certaine façon le Purebasic avec son "Protected" )
la plupart considerent que c'est Local par defaut lorsque c'est dans une procedure ou une fonction .....
mais dans tout les cas, une variable Local, n’interfère pas avec son homonyme Global !!

C'est gentil d'avoir cherché, mais ce ne sont pas des standards, comme l'ANSI ou l'ECMA. M'enfin, ça n'a pas beaucoup d'importance.

Par contre, je tiens encore à dire qu'un paramètre et une variable sont deux choses différentes. Quand on programme un langage, ou qu'on veut aller plus loin dans son utilisation, il faut savoir distinguer les deux. D'ailleurs, je connais quelques programmeur ici qui ont beaucoup utilisé Visual Basic ou QB pour qui c'est aussi évident que pour moi, qui me réfère souvent à l'assembleur.

Ainsi, il y a au moment de l'appel à une fonction, une procédure, ou une sous-routine (autres BASIC) un niveau d'abstraction imposé par l'analyseur syntaxique et par le compilateur, du fait d'un changement de contexte. Ce qui est passé en paramètres peut l'être de plusieurs façons, et influencer le comportement du programme. Ce n'est pas simplement «passer une variable en paramètre».

[Marc56]

en fait Shared permet a une variable locale a une procedure d'être partagé en dehors de la procedure

On remplace Shared par Global et on obtient le même résultat

Code : Tout sélectionner

CallDebugger

Procedure P()
      Variable_non_partage=10
EndProcedure

Procedure P2()
      Global Variable_partage ; Shared remplacé par Global
      Variable_partage=20
EndProcedure

P()
Debug Variable_non_partage ; renvoi 0

P2()
Debug Variable_partage ; renvoi 20 car cette variable est partagée

Donc quelle est la différence d'utilisation ?
Oui, je sais ce n'est pas commun d'utiliser global dans une procédure, mais ça fonctionne.
(j'ai découvert ça par hasard )

[Zorro]

Par contre, je tiens encore à dire qu'un paramètre et une variable sont deux choses différentes. Quand on programme un langage, ou qu'on veut aller plus loin dans son utilisation, il faut savoir distinguer les deux.

oui , ben personne n'a dit le contraire ici
un parametre c'est une valeur qu'on donne a une fonction , elle peut etre sous differente forme , mais pour la conversation qui nous concerne
c'est a dire la notion de variable local ou global , c'est bien de variable qu'on parle....
pour le coup c'est toi qui change le contexte de la conversation ... tu globalises

ps: je suis ici l'un des rares a avoir fait (du moins a l'avoir dit) un interpréteur qui contient un systeme de procedures recursive je dis ça , je dis rien hein ....(ben dit rien alors... oui oui je sais )
donc, je pense avoir saisi la difference ...

@Marc

je pense que la difference est interne !!

dans une procedure, les variables locales sont empilées !!
et restent dans le contexte de la procedure ...
et depilé a la sortie de celle-ci
Shared dans ce cas, permet temporairement de copier la valeur de la variable pour l'exterieur de la procedure

alors que les Variables globales, ne sont pas empilé , et sont toujours accessibles , pas de contexte (en récursivité par exemple ) !!

[Marc56]

J'ai trouvé!

Testez ceci:

Code : Tout sélectionner

Procedure P()
      Variable_non_partage=10
EndProcedure


Procedure P2()
      Shared Variable_partage ; Inversez Shared et Global
      Variable_partage=20
EndProcedure

Procedure P3()
     Debug "Variable_partage: " + Variable_partage
EndProcedure

P()
Debug Variable_non_partage ; renvoi 0

P2()
Debug Variable_partage ; renvoi 20 car cette variable est partagée

P3()

Consiste à inverser shared ou Global dans P2
Avec shared, la variable """globale""" n'est plus globale dans la procédure P3

[Zorro]

je t'avais repondu dans mon message precedent

[Marc56]

Donc Shared = Variable visible dans la procédure où elle a été déclarée
ET
dans la code principal
Mais
PAS
dans les autres procédures
Donc utile (parfois)

(j'en ai cramé des neurones )

@Zorro, oui, mais j'avais mal compris ta réponse: je suis lent

[Zorro]

oui !

dans une procedure en principe rien ne sort (aucune variable) (surtout avec "Protected" ) on lui a mis un gardien derriere les fesses ..

une procedure commence par poser sur la pile le context de son appel, et aussi les variables (donc local) qu'elle doit utiliser !
ces variables sont domestiquées !
il faut donc attendre le dépilement de chaque variable pour retrouver les contexte d'avant l'appel de la procedure
comme une pile d'assiettes ...

donc l'assiette jaune (la variable local ) se trouve quelque part dans la pile ...
pour pouvoir recuperer sa couleur (jaune ) (son contenu ) il faut preciser a la procedure qu'on veux une copie de sa valeur (jaune )
avec le mot Shared .... qui veux dire en gros :

cette variable, tu peux l'empiler , mais garde un oeil dessus, histoire de connaitre toujours sa valeur (sa couleur)


alors qu'une variable Global, c'est une variable Sauvage, elle est libre comme l'air
meme enfermé dans une procedure, elle peut traverser les murs
la procedure, ne peux pas empecher qu'on change sa valeur de l'exterieur

j'espere que mon image n'est pas trop virtuel

dans un appel recursif, une variable local , s'empile a chaque appel de la procedure, qui s'appel elle-meme
mais en realité , la variable locale A du premier appel de procedure
n'est pas la meme que la variable A du deuxiemme appel
car les deux valeur ont eté empilés !!
ça se depile a la fin au moment du END PROCEDURE

autant il y a eu d'appels , et donc d'empilements
autant il y aura de désempilement a la fin de chaque appel recursif

c'est d'ailleurs pourquoi l'utilisation de procedures pour certains traitement est trop long (perte durant l'empilement/depillement )
meme si c'ets hyper rapide de nos jours

[Marc56]

Oui, mais je n’empile pas trop mes assiettes, je suis trop maladroit

J'ai eut beau relire 20 fois la doc, je n'avais pas saisi la différence

Dixit:
Global permet à des variables d'être utilisées globalement, pouvant ainsi être accessibles depuis l'intérieur de n'importe quelle procédure
Shared permet de rendre une variable, un tableau, une liste ou une map non global accessible depuis une procédure.

Je proposerais bien une redéfinition plus simple dans la doc ?
Global: Déclarable partout et accessible partout
Shared: Déclarable dans une procédure, accessible dans la procédure où elle a été déclarée et dans le code principal mais pas dans les autres procédures

[Zorro]

oui.. c'est ça

[case]

mais dans mon exemple la variable globale n'est pas accessible du fait du paramètre ayant le mème nom
donc une variable locale crée via les paramètres d'une procédure est prioritaire sur la variable globale si elle possède le mème nom

[Marc56]

mais dans mon exemple la variable globale n'est pas accessible du fait du paramètre ayant le mème nom
donc une variable locale crée via les paramètres d'une procédure est prioritaire sur la variable globale si elle possède le mème nom

Oui, ta variable reçue en paramètre devient Protected.