Shared ou Global, lequel choisir ???

[Backup]

1/ Est ce que j'ai bien compris ma Xieme leçon donnée par mes professeurs favoris ?

oui !

2/ Pour reinitialiser un tableau on refait dim tableau(x) n'importe-ou, ou on en a besoin, et il repart a zero ?? ya pas d'autre methode ???

oui !
c'est le plus rapide !!

maintenant rien ne t'empeche de reinitialiser "a la main"
comme ça !!

Code : Tout sélectionner

Dim a(255)

For t=0 To 255
    a(t)=Random(255)
Next t
CallDebugger
; va voir dans l'explorateur de variable tableau
; on a remplis le tebleau avec des valeur aléatoire
; clique Demarrer !!




; maintenant on efface avec des 0

For t=0 To 255
    a(t)=0
Next t
CallDebugger
; va vérifier :D

[Flype]

Bon donc en résumé, les globales c'est bien, on peux en mettre mais de preference en debut de programme et eviter de les mettres dans les procedures.

c'est même pas 'de préférence' mais plutôt 'obligatoire' (si on est pas faché avec la rigueur). le mieux c'est de tester comme dobro fait très bien.

l'exemple à ne pas suivre :

Code : Tout sélectionner

Procedure TEST()
  
  Debug maVariable
  
EndProcedure

Global maVariable.l = 1234

TEST()

Debug maVariable va afficher '0'.

[Kwai chang caine]

Ouaaahh !! Meme ça je l'avais pas vraiment compris.

Si la globale est déclarée APRES la procedure elle n'est pas prise en compte par cette derniere.

Non non, je ne suis pas faché avec la rigueur, bien au contraire, j'adore ça (meme si ça ne se voit pas dans mes codes ) .

C'est pourquoi, je vous pose des questions basiques et précises et que j'insiste lourdement sur les détails pour etre bien sur d'etre rigoureux et sur de moi.

Encore merci a vous deux.
Que deviendrais-je sans vous

[Flype]

hehe, pourquoi tu crois que Dobro il met toujours ses procédures en bas ? à propos saisis-tu à quoi servent les commandes 'Declare' ?

en reprenant l'exemple à pas suivre, mais agencé comme il faut avec la présence du 'Declare'.

Code : Tout sélectionner

;================================== décalarations

Declare TEST()

;================================== globales

Global maVariable.l = 1234

;================================== début du programme

TEST() 

;================================== procédures

Procedure TEST()
  
  Debug maVariable
  
EndProcedure

;================================== fin du programme

[Kwai chang caine]

voui voui, ça je savais que de faire declare, ça permettait de mettre les procedures apres l'appel.

Mais justement, pour ne pas compliquer mon code et rajouter des lignes (a mes yeux) inutiles, j'avais vu qu'en mettant les procedures au debut j'evitais le declare.

Donc comme un benet, j'ai mis toutes mes procedures de tous mes prg en premier "pour simplifier".

En fin de compte, je n'ai pas vu d'autre interet a declare

[Flype]

tu peux faire comme tu fais.

il y a quand même un gros intérêt à 'Declare' même en mettant les procédures en haut. commente la ligne 16 tu verras :

Code : Tout sélectionner

;================================== décalarations

Declare TEST1()
Declare TEST2()

;================================== globales

Global maVariable.l = 1234

;================================== procédures

Procedure TEST1()
  
  Debug "TEST1() : " + Str(maVariable)
  
  TEST2()
  
EndProcedure

Procedure TEST2()
  
  Debug "TEST2() : " + Str(maVariable)
  
EndProcedure

;================================== début du programme

TEST1()

;================================== fin du programme 

[Kwai chang caine]

J'ai pas vraiment compris ce que tu veux dire par "commente la ligne 16 tu verras "
J'ai vu que le procedures etaient imbriquée, mais comme la variable est globale c'est normal que la valeur soit dans les deux procedures.

Par contre peut etre que tu voulais me dire qu'en declarant toutes les procedures avant, on peut les mettre dans l'ordre que l'on desire ???

Car comme je programme dab, et ça m'arrive souvent, je suis obligé de deplacer les procedures car ça plante a la compile et ecrire comme ça:

Code : Tout sélectionner

;================================== globales 

Global maVariable.l = 1234 

;================================== procédures 

Procedure TEST2() 
  
  Debug "TEST2() : " + Str(maVariable) 
  
EndProcedure 

Procedure TEST1() 
  
  Debug "TEST1() : " + Str(maVariable) 
  
  TEST2() 
  
EndProcedure 


;================================== début du programme 

TEST1() 

;================================== fin du programme 

[Kwai chang caine]

J'ai pas vraiment compris ce que tu vaux dire par "commente la ligne 16 tu verras "
Par contre j'ai vu que le procedures etaient imbriquée, mais comme la variable est globale c'est normal que la valeur soit dans les deux procedures.

Par contre peut etre que tu voulais me dire qu'en declarant toutes les procedures avant on peut les mettre dans l'ordre que l'on desire ???

Car comme je programme dab, moi, je suis obligé d'ecrire comme ça:

Code : Tout sélectionner

;================================== globales 

Global maVariable.l = 1234 

;================================== procédures 

Procedure TEST2() 
  
  Debug "TEST2() : " + Str(maVariable) 
  
EndProcedure 

Procedure TEST1() 
  
  Debug "TEST1() : " + Str(maVariable) 
  
  TEST2() 
  
EndProcedure 


;================================== début du programme 

TEST1() 

;================================== fin du programme 

[Kwai chang caine]

J'ai pas vraiment compris ce que tu vaux dire par "commente la ligne 16 tu verras "
Par contre j'ai vu que le procedures etaient imbriquée, mais comme la variable est globale c'est normal que la valeur soit dans les deux procedures.

Par contre peut etre que tu voulais me dire qu'en declarant toutes les procedures avant on peut les mettre dans l'ordre que l'on desire ???

Car comme je programme dab, moi, je suis obligé d'ecrire comme ça:

Code : Tout sélectionner

;================================== globales 

Global maVariable.l = 1234 

;================================== procédures 

Procedure TEST2() 
  
  Debug "TEST2() : " + Str(maVariable) 
  
EndProcedure 

Procedure TEST1() 
  
  Debug "TEST1() : " + Str(maVariable) 
  
  TEST2() 
  
EndProcedure 


;================================== début du programme 

TEST1() 

;================================== fin du programme 

[Backup]

hehe, pourquoi tu crois que Dobro il met toujours ses procédures en bas ? à propos saisis-tu à quoi servent les commandes 'Declare' ?

en reprenant l'exemple à pas suivre, mais agencé comme il faut avec la présence du 'Declare'.

Code : Tout sélectionner

;================================== décalarations

Declare TEST()

;================================== globales

Global maVariable.l = 1234

;================================== début du programme

TEST() 

;================================== procédures

Procedure TEST()
  
  Debug maVariable
  
EndProcedure

;================================== fin du programme

oui pour moi cette structure de programme est l'ideal d'un code procedurale

j'ai apris cette façon avec le GFA basic, c'etait une façon tres propre de présenter un prg, et cela evite bien des quiprocos

; la structure d'un prg bien ecrit


; ******declarations des procedures*********
;*****************************************

; **** initialisation des variables et structure *******
; **********************************************

; *** initialisation du dessin de l' interface utilisateur *******
; *****************************************************


; ** boucle principale ***
; execution du code
; appel des sous programmes et fonctions !!
; **********************

;** zone des sous programmes *****
; **** RETURN *****************

;*** zone des procedures ****
;**************************


;**** zone des Data ******
; ***********************

[Kwai chang caine]

Désolé pour le multipostage, ma connection etait en rade hier soir (C'est le bonheur de la campagne)

J'ai aussi fait 5/6 ans de GFA Basic.
Ce language mélange de pascal et basic.

Mais tu va rire DOBRO, des années de prog et je n'avais jamais créé une procédure.Je n'en voyais pas l'interet

Il faut dire que c'est grace a VB (Pour une fois) que j'ai été obligé d'utiliser les procedures.
D'ailleurs la premiere fois que j'ai regardé VB3 que j'avais acheté 350 Frs a la FNAC (ouh lala ça ne nous rajeunit pas tout ça), j'ai rien compris a la prog orienté evenement.
J'ai donc refermé le livre et continué en QB45.

A mon avis j'ai mal programmé des millions d'heures, mais la machine faisait ce que je voulais, alors quoi demander de plus.
Il faut dire aussi que je n'aime pas du tout les jeux, j'ai surtout fait des bases de données ASCII, alors pour ça pas besoin de prog évoluée.
Mais bon le plaisir y était quand meme.

C'est en revenant du vb que je me suis mis naturellement au procedure.

Je vais essayer de les mettre au fond, au debut j'ai hésité, mais maintenant que j'ai pris le pli, ça va etre dur.
Dommage que je ne vous connaissait pas au debut.

Tu va encore plus rire, comme j'etais strictement autodidacte, et que je n'ai jamais eu personne autour de moi qui programme, je ne voyais meme pas l'interet des forums et pas non plus des mails

Je croyais que c'etait un endroit ou on y perd son temps a parler de choses inutiles et moi je n'avais pas de temps a perdre.

Et maintenant, je suis amoureux de vous, et ne pas ecrire sur ce forum, me manque.
Internet grace a lui, je ne suis plus le seul barjo à passer jour et nuit sur une machine.
Quand je dis ça a mon entourage il ont ce regard , vous, je sais que vous avez celui la

Je ne me lasserais pas de vous remercier.

[Backup]

l'autre gros avantage a avoir les procédures en fin de listing, c'est que pour avoir accès visuellement a la boucle principale (au programme en fait)
et pour comprendre comment il marche

tu n'as pas a te taper un scrolling vertical, tres long sur de gros projet
pour passer la myriade de procédures !!
et enfin pouvoir apercevoir le Graal !

la tu passe juste les initialisations, ce qui permet d'avoir une idée de la chose par le nom des variables, puis tu accède a la création de l'interface
ce qui te donne une idée du nombre de gadgets, ect...

puis enfin la boucle principale, ou en principe il ne doit y avoir que la gestion des events, et les appels aux procédures (ET SOUS PROGRAMME)

j'insiste sur les sous programmes, car il prennent moins de place en Ram
et sont beaucoups plus rapide !!

(un sous programme est un label puis un RETURN !! )

j'aime bien les procédures , mais seulement pour résoudre un problème
bref une FONCTION quoi !!, qui tends a remplacer une fonction n'existant pas dans le purebasic par exemple

beaucoups utilisent des procedures alors qu'en principe il devrai utiliser des sous prg, car une procedure, c'est une Fonction en principe, rien d'autre ....


un sous programme, c'est un autre prg, dans le prg !!
qui peut d'ailleurs lui aussi appeler des Procedures


comme ça :

Code : Tout sélectionner

CallDebugger
; declaration
Declare.l addition(b,c)


; ***********boucle principale ***************
Debug addition(2,5) ; on affiche le premier resultat

Gosub calcul ; on saute dans le sous prg
Debug b ; on affiche le resultat en retour du sous prg !! 
; *************************



; Zone des sous prg !! 
; Sous Programme contenant un appel de procedure (fonction)
calcul:
b=addition(5,8)
Return


; zone des procedures (des fonctions)
Procedure.l addition(b,c)
    b=c+b
    ProcedureReturn b 
EndProcedure

pour la petite histoire en GFA une Procedure etait un Sous PRG !!

et ce qu'on appel "procedure" en pure Basic, etait une "Function"


pour etre clair !

en purebasic , ce que l'on appel "Procedure" devrai s'appeler "Fonction"

et ce qui n'a pas de nom (les sous prg) devrai s'apeler "Procedure" comm en GFA

[Kwai chang caine]

Tout a fait, je me rapelle maintenant
Que je trouvais ça compliqué......

Alors hop tou a la queue leu leu, ça c'etait ce qu'on appelle du procedurale de chez procedurale

Bah heureusement que tu n'a pas vu ça, tu m'aurais surement engueulé

Moi aussi j'avais cofondu procedure et sous programme.
Tu fais bien d'insister sur ce sujet.
J'en faisait plus du tout des sous programmes en PURE, je croyais que y'avais que des procedures

Par contre faut pas oublier de mettre le END ou un goto fin apres la boucle evenement pour separer les sous programmes du programme autrement le prg il saute a pied joint dans le premier sous programme d'apres, c'est ça hein ????

[Backup]

Tout a fait, je me rapelle maintenant
Que je trouvais ça compliqué......

Alors hop tou a la queue leu leu, ça c'etait ce qu'on appelle du procedurale de chez procedurale

Bah heureusement que tu n'a pas vu ça, tu m'aurais surement engueulé

Moi aussi j'avais cofondu procedure et sous programme.
Tu fais bien d'insister sur ce sujet.
J'en faisait plus du tout des sous programmes en PURE, je croyais que y'avais que des procedures

Par contre faut pas oublier de mettre le END ou un goto fin apres la boucle evenement pour separer les sous programmes du programme autrement le prg il saute a pied joint dans le premier sous programme d'apres, c'est ça hein ????

tout a fait !

comme ça :

Code : Tout sélectionner

 Enumeration
  #Window
EndEnumeration
 
Enumeration
  #ButtonGadget
EndEnumeration

 
If OpenWindow(#Window,0,0,400,400,"Pure Basic",#PB_Window_SystemMenu|#PB_Window_ScreenCentered)
  CreateGadgetList(WindowID(#Window))
  
  ButtonGadget(#ButtonGadget ,10,50,100,20,"titre")
  
  ;La boucle Repeat-Until sert à la gestion des évènements   
  Repeat
    EventID.l=WaitWindowEvent() ; on récupère un évènement
    Select EventID              ; on sélectionne cet évènement 
      Case #PB_Event_Gadget      ; cet évènement concerne une action sur un Gadget
        Select EventGadget()  ; dans ce cas, on récupère l'identifiant du gadget qui l'a créé
          Case #ButtonGadget    ; on compare l'identifiant à  #ButtonGadget
            ; si celui-ci correspond, on exécute les lignes ci-dessous
          
            Gosub sousprg_bouton
            
        EndSelect 
    EndSelect
  Until   EventID=#PB_Event_CloseWindow
EndIf

End ; TERMINE LE PRG 

sousprg_bouton:
MessageRequester("appuis sur le bouton","quelqu'un a clique sur le bouton !!",#PB_MessageRequester_Ok )
Return

[Backup]

les sous prg sont beaucoup plus souple que les procedures

car il n'y a pas d'empillement de parametres, du coup tu risque moins
de probleme en cas de Récursivité

la Grosse difference, c'est que fondamentalement un Sous prg, fonctionne
avec des Variables Global
alors qu'une procedure, par defaut , les variables sont locale

mais ensuite il faut jongler avec les deux system

une procedure Purebasic (une Fonction en faite), ne devrai etre utilisé que
pour se creer des "librairies" de fonctions, car une procedure a pour but d'etre réemployé ailleurs (dans un autre prg !)

alors qu'un sous programme est en principe "attaché" au prg en cours

le sous programme est a un niveau plus proche de l'homme que la procedure

puisqu'il peut faire appel aux procedures

un sous programme en quelque sorte "encapsule" des procedures "

c'est ce qui est montré dans l'exemple ci dessus

tu as un sous prg "sousprg_bouton:"
qui encapsule une procedure "MessageRequester()"