PureBasic

Je pense qu'il serait bien que les procédures puissent recevoir des variables Structrurées et qu'elles puisse également retourner des variables structurées.

Bref faire en sorte qu'un code comme ceci puisse fonctionner noramlement :

Code : Tout sélectionner

Structure Allo
   Texte$
   Rayon.f
   Volume.f
EndStructure  


Procedure Test(param.Allo)
   ; on fait quelque chose
EndProcedure 

Procedure.Allo Maprocedure()
   
   var\Texte$ = "Bonjour Toto"
   var\Rayon = 25
   var\Volume = 1520
   
   ProcedureReturn var.Allo
   
EndProcedure 

Alpha.Allo = Maprocedure()


Test(Alpha)

Ceci est pour éviter d'avoir des procédures avec 20 paramètres et plus.
Je sais que je pourrais utiliser les variables globales mais ...

A+
Guimauve

et en utilisant l'adesse ça ne te convient pas ?

je sais que l'on est dans la section suggestions et améliorations , et que peut-être ( sûrement même ) tu connaissais cette solution , et qu'elle ne te convient pas , dans ce cas , oublie ce post

Code : Tout sélectionner

Structure Allo
  texte$
  Rayon.f
  Volume.f
EndStructure 

Procedure Maprocedure(*var.Allo)
  *var\texte$ = "Bonjour Toto"
  *var\Rayon = 25
  *var\Volume = 1520
EndProcedure

Maprocedure(@Alpha.Allo)
Debug Alpha\texte$
Debug Alpha\Rayon
Debug Alpha\Volume

Oui je sais que ça fonctionne et que dans certain cas c'est préférable de programmer de cet manière. Mais ce que je voudrais faire c'est d'éviter de programmer une procédure pour quelle retourne une simple variable mais plutôt un point 3D.

Alors une procédure comme celle-ci :

Code : Tout sélectionner

Procedure.f Helice3D(rayon.f, NbSpire.f, Pas.f, Pos_u.f, Calcul.b) 
      
     If Calcul = #CoordonneeX 
          Resultat.f = rayon * Cos(DegToRad(360 * NbSpire * Pos_u)) 
          
     ElseIf Calcul = #CoordonneeY 
          Resultat.f = rayon * Sin(DegToRad(360 * NbSpire * Pos_u)) 
          
     ElseIf Calcul = #CoordonneeZ 
          Resultat.f = Pas * NbSpire * Pos_u 
          
     EndIf 
      
     ProcedureReturn Resultat 
EndProcedure

Deviendrait comme ceci :

Code : Tout sélectionner

Procedure.Pt3D Helice3D(rayon.f, NbSpire.f, Pas.f, Pos_u.f) 
      
          Resultat.Pt3D\x = rayon * Cos(DegToRad(360 * NbSpire * Pos_u)) 
          
          Resultat.Pt3D\y = rayon * Sin(DegToRad(360 * NbSpire * Pos_u)) 
          
          Resultat.Pt3D\z = Pas * NbSpire * Pos_u 

     ProcedureReturn Resultat.Pt3D 
EndProcedure

Le principal avantage entre les deux procédures c'est que dans le 2e cas il n'y a aucun test d'effectué pour savoir quelle coordonnée doit être calculé. Puisque de toute façon, je vais faire les 3 calculs, j'ai besoin des 3 coordonnées pour travailler.

Et bien sûr si une fonction peut retrourner une variable structurée il me semble logique qu'elle puisse en recevoir également.

L'autre option serait d'avoir des retours multiples. La même procédure deviendrait alors :

Code : Tout sélectionner

Procedure.f Helice3D(rayon.f, NbSpire.f, Pas.f, Pos_u.f) 
      
          x.f = rayon * Cos(DegToRad(360 * NbSpire * Pos_u)) 
          
          y.f = rayon * Sin(DegToRad(360 * NbSpire * Pos_u)) 
          
          z.f = Pas * NbSpire * Pos_u 

     ProcedureReturn {x,y,z}
EndProcedure 

; Et à l'appel :
{CoorDx,CoorDy,CoorDz} = Helice3D(rayon.f, NbSpire.f, Pas.f, Pos_u.f)

Donc la procédure place la valeur de x dans CoorDx, le y dans CoorDy et le z dans CoorDz.

Sauf que je n'aime pas vraiment cette dernière méthode.

Mais bon je ne fais qu'une simple suggestion. C'est à Fred de voir s'il peut faire quelque chose du genre.

Mais je sais que c'est possible, dans MatLab ces 2 méthodes fonctionnent, les retours multiples et le retour de variables structurés.

A+
Guimauve

J'ai oublié de décrire la structure Pt3D :

Code : Tout sélectionner

Structure Pt3D
   X.f
   Y.f
   Z.f
EndStructure

Juste au cas ou ça ne serait pas clair.

A+
Guimauve

n'oublie pas qu'on peut utiliser cette syntaxe pour transformer un pointeur en structure :

Code : Tout sélectionner

Structure P3D
  x.f
  y.f
  z.f 
EndStructure

Procedure.l PointTo3D(*p.POINT)
  
  p3.P3D
  p3\x = *p\x * 10
  p3\y = *p\y * 10
  p3\z = 100
  
  ProcedureReturn p3
  
EndProcedure

a.POINT
a\x = 2
a\y = 4

*b.P3D = PointTo3D(a)
Debug *b\x
Debug *b\y
Debug *b\z

Ça marche pas:

Code : Tout sélectionner

Structure P3D
  x.f
  y.f
  z.f
EndStructure

Procedure.l PointTo3D(*p.POINT)
 
  p3.P3D
  p3\x = *p\x * 10
  p3\y = *p\y * 10
  p3\z = 100
 
  ProcedureReturn p3  ;<- retourne un pointeur vers une variable locale ! Bouh!
 
EndProcedure

a.POINT
a\x = 2
a\y = 4

*b.P3D = PointTo3D(a)
MessageRequester("","Youplàboum !!")
Debug *b\x
Debug *b\y
Debug *b\z

Il faut réserver la mémoire:

Code : Tout sélectionner

Structure P3D
  x.f
  y.f
  z.f
EndStructure

Procedure.l PointTo3D(*p.POINT)
 
  *p3.P3D=AllocateMemory(SizeOf(P3D))  ; <- faudra aussi penser à libérer la mémoire le moment venu...
  *p3\x = *p\x * 10
  *p3\y = *p\y * 10
  *p3\z = 100
 
  ProcedureReturn *p3
 
EndProcedure

a.POINT
a\x = 2
a\y = 4

*b.P3D = PointTo3D(a)
MessageRequester("","Youplàboum !!")
Debug *b\x
Debug *b\y
Debug *b\z

Écouter les copains, j'apprécie vos conseils, sauf que ce que je propose d'ajouter c'est une manière différente de faire les choses sans passer par les pointeurs.

Guimauve

PureBasic

Procédures et Structures

Procédures et Structures