Procedure Parametres

[Jeanmarc]

Bonjour,

Je voudrais passer une paramètre Variable à une procédure,
Que celle-ci le modifie et que la variable passée soit modifiée.

Code : Tout sélectionner

Procedure Addi(v)
v=v+1
ProcedureReturn
EndProcedure

Procedure Principale()
var=1
Addi(var)
Debug var    var=2
Addi(var)
Debug var    var=3

EndProcedure

Cela doit être possible, mais je n'y arrive pas.

Bon dimanche,
JM

[Ar-S]

Déclare tes procédures, ça permet la communication entre elles sans te soucier de leur positionnement, ça te sera pratique par la suite.
Ensuite, donnes à ta variable var la valeur de ton addition Addi(v)

Code : Tout sélectionner

Declare Addi(v)
Declare Principale() 

Procedure Addi(v)
  ProcedureReturn v+1
EndProcedure

Procedure Principale()
var=1
var = Addi(var)
Debug var  ;  var=2
var = Addi(var)
Debug var  ;  var=3

EndProcedure

Principale()

Tu pourrais mettre directement Debug Addi(var) mais le résultat serait 2 à chaque coup vu que Addi() s’additionne à Var or ton var = 1

[Jeanmarc]

Merci Ar-S,

Oui bien sur cela fonctionne mieux ainsi,

je faisais : Addi(var) mais avec: var = Addi(var) c'est parfait.

Bon dimanche à toi,
JM

[Ollivier]

Bonjour à vous,

une technique un peu plus délicate quand on veut modifier plusieurs paramètres d'une procédure est de travailler par pointeur. C'est utilisé par certaines fonctions externes.

Code : Tout sélectionner

Procedure MyProc(*A.INTEGER, *B.INTEGER)
*A\I = 33
*B\I = 34
EndProcedure

Define.I x, y

MyProc(@x, @y)
Debug x
Debug y

C'est Gnozal qui m'avait montré ça il y a quelques années.

[Jeanmarc]

Oui Ollivier,

J'avais essayé avec * et @ mais que des problèmes de syntaxe.

C'est quoi le \ après *A ?

Ce n'est pas urgent.
Je mets ton exemple de coté.

Bonne soirée,
JM

[Ollivier]

Le symbole que tu montres c'est utilisé pour préciser ce que tu pointes. Un pointeur ( = une variable contenant une adresse mémoire) peut pointer toute sorte de chose tant que ça se situe dans une zone mémoire valide.

Pour architecturer un espace mémoire, on utilise un modèle communément appelé "structure". Il existe une poignée de structures simples respectives à chaque type de variable.

Je vais t'écrire un exemple...

[Ollivier]

On va considérer que "statique" c'est ce qui est alloué en mémoire sans pouvoir l'effacer durant l'exécution du programme.
Et "dynamique" c'est ce que l'on peut allouer et libérer à la volée.

Ainsi, une variable basique est statique : une fois définie, impossible de l'effacer. Or, il y a des variables qui sont dynamiques : c'est le cas des paramètres d'une procédure.

Code : Tout sélectionner

Define Alpha.I = 36

Procedure MaProc(Beta.I)
EndProcedure

Ici Alpha est statique et Beta est dynamique.

Code : Tout sélectionner

Structure UnEntier
I.I
EndStructure

Procedure Proc(*Gamma.INTEGER, *Yankee.UnEntier)
*Gamma\I = 13
*Yankee\I = 27
EndProcedure

Define A.I, B.I
Proc(@A, @B)
Debug A
Debug B

Les pointeurs *Gamma et *Yankee sont dynamiques : ils vont servir durant l'exécution de la procédure puis être supprimés.
Tu noteras que l'écriture de 13 et 27 s'écrit pareillement (avec un \I ).
Ceci parce qu'en natif, il y a un ensemble de structures prédéfinies. Notamment, celle-là :

Code : Tout sélectionner

Structure INTEGER
I.I
EndStructure

Au passage, il y en a pour tous les types de variable :

Code : Tout sélectionner

Structure FLOAT
F.F
EndStructure

Structure DOUBLE
D.D
EndStructure

Structure LONG
L.L
EndStructure

Structure BYTE
B.B
EndStructure

Structure QUAD
Q.Q
EndStructure

Structure STRING
S.S
EndStructure

; Etc...

Aussi, rien ne t'empêche de changer de nom de membre à ta structure.

Code : Tout sélectionner

Structure UnEntier
Solo.I
EndStructure

Procedure Proc(*Gamma.INTEGER, *Yankee.UnEntier)
*Gamma\I = 13
*Yankee\Solo = 27
EndProcedure

Define A.I, B.I
Proc(@A, @B)
Debug A
Debug B

Ici, c'est le même exemple mais avec "Solo" (ou "Pif", "paf", etc...) à la place de "I".

[Ollivier]

ça vole bas les pub en bas de page : "Quel animal te correspond le plus au lit"
Ils sont complètement marbrés...

[Ollivier]

Les acariens.

[Marc56]

Je voudrais passer une paramètre Variable à une procédure,
Que celle-ci le modifie et que la variable passée soit modifiée.

En PB, contrairement à d'autres langages comme le Pascal/Delphi, il n'y a pas de différence entre une Procédure (bloc de code) et une Fonction (transformation d'une donnée).

Une procédure devient une fonction avec deux conditions, dixit la doc:
« Une procédure peut renvoyer une valeur de retour. Pour cela, il faut deux choses. Premièrement, il faut définir le type de donnée de retour après Procedure qui peut être 'Integer', 'Long', 'Float', 'String' ou autre puis utiliser le mot clef ProcedureReturn pour déclencher le retour. »

Autrement dit: définition du type de donnée retournée et ProcedureReturn suivi de la valeur à renvoyer.
Voir et tester les exemples dans l'aide.

Il y a d'autres possibilités:
http://www.purebasic.com/french/documen ... dures.html

[Zorro]

en reprenant ton exemple :

Code : Tout sélectionner

Declare addi(v)
Declare principale()
calldebugger

Principale()
debug "fin"



; ******* Procedure Zone ******************

Procedure Addi(v)
	v=v+1
	ProcedureReturn V
EndProcedure

Procedure Principale()
	var =1 
	Debug "Var avant appel numero 1 ="+str(var)
	var= Addi(var)	
	Debug "Var Apres appel numero 1 ="+str(var) 	
	var=2
	Debug "Var avant appel numero 2 ="+str(var)
	var=Addi(var)
	Debug "Var Apres appel numero 2 ="+str(var) 	
	var=3
	
EndProcedure 

et voici en utilisant une structure

Code : Tout sélectionner

Declare addi(v)
Declare principale()
calldebugger

; exemple sans utiliser ProcedureReturn mais en utilisant une structure

; on creer une structure pour la variable Var
Structure Var
	Valeur.i
EndStructure
Global Var.var ; ici on la declare

Principale()
debug "fin"



; ******* Procedure Zone ******************

Procedure Addi(v)
	v=v+1
	Var\valeur.i=v ; ici on attribut la nouvelle valeur de la variable v a la variable structuré Var\valeur.i
EndProcedure

Procedure Principale()
	
	var\valeur.i =1 
	Debug "Var avant appel numero 1 ="+str(var\valeur.i)  ; voici donc le contenu de la variable structuré 
	Addi(var\valeur.i)	 ; <---- plus besoin de variable pour le retour de procedure , puisque le resultat est directement mis dans le membre "Valeur.i" de la structure 
	Debug "Var Apres appel numero 1 ="+str(var\valeur.i) 	 ; voici donc le contenu de la variable structuré 
	var\valeur.i=2
	Debug "Var avant appel numero 2 ="+str(var\valeur.i) ; voici donc le contenu de la variable structuré 
	Addi(var\valeur.i)  ; <---- plus besoin de variable pour le retour de procedure , puisque le resultat est directement mis dans le membre "Valeur.i" de la structure 
	Debug "Var Apres appel numero 2 ="+str(var\valeur.i) 	  ; voici donc le contenu de la variable structuré 
	var\valeur.i=3
	
EndProcedure