PureBasic

Forums PureBasic
Nous sommes le Mar 15/Oct/2019 17:50

Heures au format UTC + 1 heure




Poster un nouveau sujet Répondre au sujet  [ 7 messages ] 
Auteur Message
 Sujet du message: Problème modules
MessagePosté: Jeu 21/Juin/2018 9:35 
Hors ligne
Avatar de l’utilisateur

Inscription: Jeu 25/Aoû/2005 22:59
Messages: 445
Localisation: 974
Bonjour,

J'aimerais utiliser les modules, mais il y a un truc que je n'arrive pas à faire...

Mon fichier main.pb :
Code:
toto = #PI
IncludeFile ("testmod.pb")
testmod::test()


Mon fichier testmod.pb :
Code:
DeclareModule testmod
  Declare test()
EndDeclareModule

Module testmod
  Procedure test ()
    i = toto
    MessageRequester ("Test", "i = " + Str (i))
  EndProcedure
EndModule


A partir du module testmod, je n'arrive pas à accéder à la variable toto. (j'ai aussi éssayé de la déclarer en Global mais c'est pareil)
Il y a surement un truc que j'ai pas pigé....

_________________
Quelques manoucheries : I can't give you anything but love / Stompin' at decca


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Problème modules
MessagePosté: Jeu 21/Juin/2018 9:39 
Hors ligne
Avatar de l’utilisateur

Inscription: Jeu 25/Aoû/2005 22:59
Messages: 445
Localisation: 974
Bon...Ca marche en déclarant toto dans un module "mainmod" et en y accedant en faisant mainmod::toto

_________________
Quelques manoucheries : I can't give you anything but love / Stompin' at decca


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Problème modules
MessagePosté: Jeu 21/Juin/2018 9:42 
Hors ligne
Avatar de l’utilisateur

Inscription: Jeu 25/Aoû/2005 22:59
Messages: 445
Localisation: 974
Apparement on ne peut pas déclarer un module dans un module ?

Encore une autre question :
Dans mon module main j'ai déclaré une structure
Comment faire pour déclarer une variable de ce type dans mon module testmod ?
Evidemment je ne peut pas faire Dim tab.main::mastruct (10) ca ne marche pas :roll:
Par contre si je fait un usemodule juste avant, là ca marche, mais préfererait éviter le UseModule

_________________
Quelques manoucheries : I can't give you anything but love / Stompin' at decca


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Problème modules
MessagePosté: Jeu 21/Juin/2018 10:36 
Hors ligne
Avatar de l’utilisateur

Inscription: Jeu 25/Aoû/2005 22:59
Messages: 445
Localisation: 974
aaaah j'ai trouvé... en fait c'est un bug de la completion de l'IDE

1) je déclare une structure mastruct dans mon module main
2) dans mon module testmod je définis ma variable :
Code:
Dim pouet.main::mastruct (10)

Et bien ca compile et ca a l'air de marcher
Par contre après avoir tapé les "::" la complétion ne me propose pas "mastruct"

_________________
Quelques manoucheries : I can't give you anything but love / Stompin' at decca


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Problème modules
MessagePosté: Jeu 21/Juin/2018 13:18 
Hors ligne
Avatar de l’utilisateur

Inscription: Dim 02/Oct/2011 16:17
Messages: 2186
Localisation: 50200 Coutances
Le manuel PureBasic définit les modules comme suit :
Les modules sont un moyen facile d'isoler une partie du code du code principal, ce qui permet de réutiliser et de partager le code sans risque de conflit de nom. Dans d'autres langages de programmation, les modules sont appelés `espaces de noms'.

Techniquement, les modules sont des mini-programmes dans le cadre de programmes plus vastes, que l'on pourrait appeler des procédures. Mais contrairement aux procédures, ils exécutent leur code immédiat sans que le programme parent ne les appelle. De plus, contrairement aux procédures, les modules pourraient aussi contenir leurs propres procédures.

Démontrons cela avec quelques exemples simples. Considérez cette procédure vide :
Code:
Procedure maProcedure()
EndProcedure

Le module équivalent de la procédure ci-dessus serait cet ensemble de fermetures :
Code:
DeclareModule monModule 
EndDeclareModule

Module monModule   
EndModule

À ce stade, ils ne font absolument rien. Donc, ajoutons une variable à la procédure :
Code:
Procedure maProcedure()
  Protected maVar = 123
EndProcedure

Nous savons que la variable maVar n'est pas accessible depuis le programme parent, et essayer d'y accéder ne ferait que générer une nouvelle variable du même nom dans le programme parent, avec pour résultat une valeur zéro :
Code:
Procedure maProcedure()
  Protected maVar = 123
EndProcedure

Debug maProcedure()  ;== 123

Des trucs simples et basiques.

Dans le cas des modules, il y aurait deux façons d'ajouter des variables. C'est la première façon :
Code:
DeclareModule monModule
EndDeclareModule

Module monModule 
  Define maVar = 123
EndModule

Et ce serait la deuxième façon :
Code:
DeclareModule monModule
  Define maVar = 123
EndDeclareModule

Module monModule 
EndModule

Quelle est la différence ? Avant de répondre à cette question, jetons un autre coup d'œil à la structure de base du module :
Code:
DeclareModule monModule
EndDeclareModule

Module monModule   
EndModule

Comme le nom de la fonction l'indique, la section supérieure DeclareModule gère les déclarations du module, tandis que la section inférieure du module abrite toutes ses fonctions. Cependant, tout le code de la section module resterait verrouillé et inaccessible au programme parent à moins qu'ils ne soient sélectivement et expressément déclarés dans la section de déclaration supérieure. Pour illustrer cela, revenons à l'exemple précédent de la variable.

Dans le premier des deux exemples de modules, la variable maVar a été déclarée dans la section inférieure du module :
Code:
DeclareModule monModule
EndDeclareModule

Module monModule 
  Define maVar = 123
EndModule

Comme la procédure précédente, les variables dans les modules ne sont pas accessibles à partir du programme parent, et essayer d'y accéder ne ferait que générer une nouvelle variable du même nom dans le programme parent, avec pour résultat une valeur zéro :
Code:
DeclareModule monModule
EndDeclareModule

Module monModule 
  Define maVar = 123
EndModule

Debug maVar  ;== 0

Contrairement aux procédures, qui devraient retourner la valeur de la variable au programme parent, les variables des modules peuvent être référencées et accédées directement. La syntaxe pour le référencement des variables dans les modules du programme parent serait de les préfixer avec le nom du module, comme suit :
Code:
DeclareModule monModule
EndDeclareModule

Module monModule 
  Define maVar = 123
EndModule

Debug monModule::maVar  ;== 0 ?

Cependant, vous remarquerez que la sortie résultante est toujours à zéro. Pourquoi cela ?

Comme indiqué précédemment, les variables et les fonctions contenues dans les modules ne sont pas accessibles par le programme parent à moins qu'elles ne soient expressément mises à disposition. Et cela se fait en les déclarant dans la section de déclaration supérieure de la structure du module.

Pour remédier à cela, et rendre la variable accessible, il faudrait utiliser la deuxième méthode, qui déclare la variable maVar, comme ça :
Code:
DeclareModule monModule
  Define maVar = 123
EndDeclareModule

Module monModule 
EndModule

Debug monModule::maVar  ;== 123

De plus, les valeurs de ces variables publiques n'ont pas besoin d'être assignées dans la section déclarations, et pourraient également être assignées dans le corps du module, comme c'est le cas :
Code:
DeclareModule monModule
  Define maVar
EndDeclareModule

Module monModule
  maVar = 123
EndModule

Debug monModule::maVar  ;== 123

Alors, que pouvons-nous faire d'autre avec les modules ?

Les procédures sont excellentes pour moduler les fonctions réutilisables, ce qui évite d'avoir besoin d'un code répétitif et fastidieux. Cependant, dans le meilleur des cas, chaque procédure ne peut exécuter qu'une poignée de processus. Considérez ceci :
Code:
Procedure maProcedure(a, b)   
  c = a + b
  ProcedureReturn c
EndProcedure

Debug maProcedure(1, 2) ; == 3

L'équivalent module de la procédure ci-dessus ressemblerait à ceci :
Code:
DeclareModule monModule
  Declare maProcedure(a, b))
EndDeclareModule

Module monModule 
  Procedure maProcedure(a, b)   
    c = a + b
    ProcedureReturn c
  EndProcedure
EndModule

Debug monModule::maProcedure(1, 2) ; == 3

Remarquez comment la même procédure a été ajoutée dans le module, et remarquez comment elle a également été déclarée dans la section supérieure de déclaration. Il est ensuite appelé dans la même méthode, en préfixant le nom du module au nom de la procédure.

Au fond, c'est tout ce qu'il y a aux modules. Une procédure glorifiée avec son propre espace de noms. Bien que c'est là que s'arrêtent les similitudes entre les procédures et les modules.

_________________
Microsoft Windows 10 Famille 64 bits : Carte mère : ASRock 970 Extreme3 R2.0 : Carte Graphique NVIDIA GeForce GT 640 : Processeur AMD FX 6300 6 cœurs 12 threads 3,50 GHz PB 5.62, 5.70 LTS
Un homme doit être poli, mais il doit aussi être libre !


Dernière édition par Micoute le Jeu 21/Juin/2018 15:37, édité 1 fois.

Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Problème modules
MessagePosté: Jeu 21/Juin/2018 13:18 
Hors ligne
Avatar de l’utilisateur

Inscription: Dim 02/Oct/2011 16:17
Messages: 2186
Localisation: 50200 Coutances
Le manuel PureBasic définit les modules comme suit :
Les modules sont un moyen facile d'isoler une partie du code du code principal, ce qui permet de réutiliser et de partager le code sans risque de conflit de nom. Dans d'autres langages de programmation, les modules sont appelés `espaces de noms'.

Techniquement, les modules sont des mini-programmes dans le cadre de programmes plus vastes, que l'on pourrait appeler des procédures. Mais contrairement aux procédures, ils exécutent leur code immédiat sans que le programme parent ne les appelle. De plus, contrairement aux procédures, les modules pourraient aussi contenir leurs propres procédures.

Démontrons cela avec quelques exemples simples. Considérez cette procédure vide :
Code:
Procedure myProcedure()
EndProcedure

Le module équivalent de la procédure ci-dessus serait cet ensemble de fermetures :
Code:
DeclareModule monModule 
EndDeclareModule

Module monModule   
EndModule

À ce stade, ils ne font absolument rien. Donc, ajoutons une variable à la procédure :
Code:
Procedure maProcedure()
  Protected maVar = 123
EndProcedure

Nous savons que la variable myVar n'est pas accessible depuis le programme parent, et essayer d'y accéder ne ferait que générer une nouvelle variable du même nom dans le programme parent, avec pour résultat une valeur zéro :
Code:
Procedure maProcedure()
  Protected maVar = 123
EndProcedure

Debug maProcedure()  ;== 123

Des trucs simples et basiques.

Dans le cas des modules, il y aurait deux façons d'ajouter des variables. C'est la première façon :
Code:
DeclareModule monModule
EndDeclareModule

Module monModule 
  Define maVar = 123
EndModule

Et ce serait la deuxième façon :
Code:
DeclareModule monModule
  Define maVar = 123
EndDeclareModule

Module monModule 
EndModule

Quelle est la différence ? Avant de répondre à cette question, jetons un autre coup d'œil à la structure de base du module :
Code:
DeclareModule monModule
EndDeclareModule

Module monModule   
EndModule

Comme le nom de la fonction l'indique, la section supérieure DeclareModule gère les déclarations du module, tandis que la section inférieure du module abrite toutes ses fonctions. Cependant, tout le code de la section module resterait verrouillé et inaccessible au programme parent à moins qu'ils ne soient sélectivement et expressément déclarés dans la section de déclaration supérieure. Pour illustrer cela, revenons à l'exemple précédent de la variable.

Dans le premier des deux exemples de modules, la variable maVar a été déclarée dans la section inférieure du module :
Code:
DeclareModule monModule
EndDeclareModule

Module monModule 
  Define maVar = 123
EndModule

Comme la procédure précédente, les variables dans les modules ne sont pas accessibles à partir du programme parent, et essayer d'y accéder ne ferait que générer une nouvelle variable du même nom dans le programme parent, avec pour résultat une valeur zéro :
Code:
DeclareModule monModule
EndDeclareModule

Module monModule 
  Define maVar = 123
EndModule

Debug maVar  ;== 0

Contrairement aux procédures, qui devraient retourner la valeur de la variable au programme parent, les variables des modules peuvent être référencées et accédées directement. La syntaxe pour le référencement des variables dans les modules du programme parent serait de les préfixer avec le nom du module, comme suit :
Code:
DeclareModule monModule
EndDeclareModule

Module monModule 
  Define maVar = 123
EndModule

Debug monModule::maVar  ;== 0 ?

Cependant, vous remarquerez que la sortie résultante est toujours à zéro. Pourquoi cela ?

Comme indiqué précédemment, les variables et les fonctions contenues dans les modules ne sont pas accessibles par le programme parent à moins qu'elles ne soient expressément mises à disposition. Et cela se fait en les déclarant dans la section de déclaration supérieure de la structure du module.

Pour remédier à cela, et rendre la variable accessible, il faudrait utiliser la deuxième méthode, qui déclare la variable myVar, comme ça :
Code:
DeclareModule monModule
  Define maVar = 123
EndDeclareModule

Module monModule 
EndModule

Debug monModule::maVar  ;== 123

De plus, les valeurs de ces variables publiques n'ont pas besoin d'être assignées dans la section déclarations, et pourraient également être assignées dans le corps du module, comme c'est le cas :
Code:
DeclareModule monModule
  Define maVar
EndDeclareModule

Module monModule
  maVar = 123
EndModule

Debug monModule::maVar  ;== 123

Alors, que pouvons-nous faire d'autre avec les modules ?

Les procédures sont excellentes pour moduler les fonctions réutilisables, ce qui évite d'avoir besoin d'un code répétitif et fastidieux. Cependant, dans le meilleur des cas, chaque procédure ne peut exécuter qu'une poignée de processus. Considérez ceci :
Code:
Procedure maProcedure(a, b)   
  c = a + b
  ProcedureReturn c
EndProcedure

Debug maProcedure(1, 2) ; == 3

L'équivalent module de la procédure ci-dessus ressemblerait à ceci :
Code:
DeclareModule monModule
  Declare maProcedure(a, b))
EndDeclareModule

Module monModule 
  Procedure maProcedure(a, b)   
    c = a + b
    ProcedureReturn c
  EndProcedure
EndModule

Debug monModule::maProcedure(1, 2) ; == 3

Remarquez comment la même procédure a été ajoutée dans le module, et remarquez comment elle a également été déclarée dans la section supérieure de déclaration. Il est ensuite appelé dans la même méthode, en préfixant le nom du module au nom de la procédure.

Au fond, c'est tout ce qu'il y a aux modules. Une procédure glorifiée avec son propre espace de noms. Bien que c'est là que s'arrêtent les similitudes entre les procédures et les modules.

_________________
Microsoft Windows 10 Famille 64 bits : Carte mère : ASRock 970 Extreme3 R2.0 : Carte Graphique NVIDIA GeForce GT 640 : Processeur AMD FX 6300 6 cœurs 12 threads 3,50 GHz PB 5.62, 5.70 LTS
Un homme doit être poli, mais il doit aussi être libre !


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Problème modules
MessagePosté: Jeu 21/Juin/2018 13:30 
Hors ligne
Avatar de l’utilisateur

Inscription: Jeu 25/Aoû/2005 22:59
Messages: 445
Localisation: 974
Merci Micoute pour ton aide !

J'ai réussi à modulariser mon programme....
J'ai eu quelques problèmes pour accéder à la DataSection mais c'est bon ca marche

:D

_________________
Quelques manoucheries : I can't give you anything but love / Stompin' at decca


Haut
 Profil  
Répondre en citant le message  
Afficher les messages postés depuis:  Trier par  
Poster un nouveau sujet Répondre au sujet  [ 7 messages ] 

Heures au format UTC + 1 heure


Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 2 invités


Vous ne pouvez pas poster de nouveaux sujets
Vous ne pouvez pas répondre aux sujets
Vous ne pouvez pas éditer vos messages
Vous ne pouvez pas supprimer vos messages

Rechercher:
Aller à:  

 


Powered by phpBB © 2008 phpBB Group | Traduction par: phpBB-fr.com
subSilver+ theme by Canver Software, sponsor Sanal Modifiye