PureBasic

salut,

voila j'aimerai savoir comment définir les méthodes déclarées dans une "interface" , j'ai regarder le fichier aide mais ça me parait bien vague !

si quelqu'un peux m'éclairer sur le sujet çe serai sympa merci !

Désolé, Silver, personne ne répond à ta question et c'est vrai que la doc n'explique que comment UTILISER des interfaces, pas comment en CREER. Nous sommes vraiment trés peu avoir utilisé les interfaces et pour ce qui me concerne, je n'en ai jamais créé.

Y'a quelqu'un pour aider Silver ??? (la réponse à sa question m'intéresse)

Tout ce que je peux dire, c'est que j'ai vu des sujets là-dessus sur le forum anglais.
Mais pour dire comment ça fonctionne...

Chris

je vais étudier le sujet car il est vrai que çà m'intrigue aussi.
j'y ai lu des choses sur le forum anglais, et ce que je peux dire
c que ca semble génial.
en tout cas pour ceux qui aime la programmation objet ( moi oui )

je vous fait un topo rapidement avec un exemple clair et soigné

apres tres breve etude du sujet voici un exemple complet
je pretend pas faire le tour du sujet. il semble bien vaste

apparemment on peut utiliser les interfaces en gros de deux facons
1 avec des interfaces externes, déjà programmées, un peu comme les dll
1 autre avec nos propres interfaces, nos propres objets accompagnées de leurs méthodes.

mon exemple s'inscrit dans cette deuxieme optique.
d'ailleurs cet exemple est honnetement calqué sur un source du forum anglais sauf qu'ici on va faire vivre quelques poules qui illustrerons l'objet "Poule". On part du principe qu'une poule çà picore, çà pond, çà chante. Et que si çà pond c'est que çà donne vie.

voici donc le code à executer en mode debug :

Code : Tout sélectionner

;/---------------------------------------------------
;- DECLARATION DES METHODES DE L'OBJET
;/---------------------------------------------------

Interface Poule
  Picorer()
  Pondre ( Nom.s )
  Chanter( Message.s )
EndInterface

Structure Poule_TableVirtuelle
  Picorer.l 
  Pondre.l 
  Chanter.l 
EndStructure

;/---------------------------------------------------
;- DECLARATION DES ATTRIBUTS DE L'OBJET
;/---------------------------------------------------

Structure Poule_Structure
  *TableVirtuelle.Poule_TableVirtuelle ; Indispensable
  Nom.s
  Couleur.s
  NombreOeufs.l
EndStructure

;/---------------------------------------------------
;- DECLARATION DES PROCEDURES DE L'OBJET
;/---------------------------------------------------

Declare CreerPoule( Parametres.s )
Declare Picorer   ( *Self.Poule_Structure )
Declare Pondre    ( *Self.Poule_Structure, Parametre.s )
Declare Chanter   ( *Self.Poule_Structure, Message.s )

;/---------------------------------------------------
;- DEFINITION DES METHODES DE L'OBJET
;/---------------------------------------------------

Procedure Picorer( *Self.Poule_Structure )
  Debug *Self\Nom + " vient de picorer"
EndProcedure

Procedure Pondre( *Self.Poule_Structure, Parametres.s )
  *Self\NombreOeufs + 1
  Debug *Self\Nom + " vient de pondre"
  ProcedureReturn CreerPoule( Parametres )
EndProcedure

Procedure Chanter( *Self.Poule_Structure, Message.s )
  Debug PeekS(*Self\Nom) + " chante " + Message
EndProcedure

;/---------------------------------------------------
;- ATTACHEMENT DES METHODES A L'OBJET
;/---------------------------------------------------

Global Poule_Global.Poule_TableVirtuelle

Poule_Global\Picorer = @Picorer()
Poule_Global\Pondre  = @Pondre()
Poule_Global\Chanter = @Chanter()

;/---------------------------------------------------
;- CREATION D UNE LISTE CONTENANT LES OBJETS
;/---------------------------------------------------

NewList Instances.Poule_Structure()

;/---------------------------------------------------
;- DEFINITION DU CONSTRUCTEUR : CREATION D'UN OBJET
;/---------------------------------------------------

Procedure.l CreerPoule( Parametres.s )
  Nom.s     = StringField( Parametres, 1, ";" )
  Couleur.s = StringField( Parametres, 2, ";" )
  AddElement(Instances())
  Instances()\TableVirtuelle = Poule_Global
  Instances()\Nom         = Nom
  Instances()\Couleur     = Couleur
  Instances()\NombreOeufs = 0
  Debug Nom + " vient de naitre. Ho ! elle est " + Couleur
  ProcedureReturn @Instances()
EndProcedure

;/---------------------------------------------------
;- PROGRAMME PRINCIPAL
;/---------------------------------------------------

Poule1.Poule = CreerPoule("Poule De Basse Cours;Marron")
Poule2.Poule = CreerPoule( "Poule De Luxe;Jaune" )
Debug "---"
Poule1\Picorer()
Poule1\Picorer()
Poule1\Picorer()
Poule3.Poule = Poule1\Pondre( "Poulette;Noire" )
Poule4.Poule = Poule1\Pondre( "Poussin;Bleu" )
Debug "---"
Poule2\Picorer()
Poule2\Chanter("Cocoricooo")
Poule2\Picorer()
Poule2\Chanter("Cocorico")
Debug "---"
Poule3\Picorer()
Poule3\Chanter("CuiCui")
Debug "---"
ForEach Instances()
  Debug Instances()\Nom + " a donc pondu "+Str(Instances()\NombreOeufs) + " oeufs"
Next
Debug "---"
ForEach Instances()
  x.Poule=Instances()
  x\Chanter("Au revoir")
Next
Debug "---"
Debug "Fin"
End

Commentaires:"

Ah quand meme, c pas si simple...
Les déclarations sont longues et demande une certaine habitude
Par contre, à l'usage dans le programme principale, çà laisse entrevoir
de belles possiblités.

aure remarque : les méthodes ne peuvent comporter plus d'un argument

exemple

Pondre( *Self.Poule_Structure, Parametres.s )

mais pas

Pondre( *Self.Poule_Structure, Nom.s, Couleur.s )

merci flype pour ton explication c cool

!

sinon c bien compliqué tout ça

! dommage qu'on puisse pas mettre plus d'arguments...

enfin bon c deja ça , allez bonne prog a tous

L' avantage des interfaces window (Objet ole), c'est que n'importe qu'elle programme peut utiliser les fonctions de l'interface et profiter de ses avantages.Mais créer ses interfaces va servir à quoi, quel intéret il y a ?

Pour me donner tort, comme je peux le voir dans la doc, à priori, les interfaces prennent bien en compte plusieurs arguments :

Code : Tout sélectionner

Interface MyObject
  Move(x,y)
  MoveF(x.f,y.f)
  Destroy()
EndInterface

moi j'ai eu qq problemes... mais bon j'ai surement pas tout compris.

c'est quand meme beaucoup plus simple en c++ la poo

sauf exception, moi j'attendrais qq évolutions majeurs pour utiliser tout çà...

comme les class en cpp, bocoup plus intuitif

nico a écrit :L' avantage des interfaces window (Objet ole), c'est que n'importe qu'elle programme peut utiliser les fonctions de l'interface et profiter de ses avantages.Mais créer ses interfaces va servir à quoi, quel intéret il y a ?

Non, c'est des objets COM (Component Object Model), l'OLE c'est la capacité à intégrer dans son application l'interface d'une autre (Excel, Word dans un prog VB par exemple).

cederavic>c'est clair ! Je sais pas pourquoi mais j'ai jamais trop aimé cette norme (le COM), je préfere une bonne implémentation en C++

Alors, à quoi sert de créer ses propres interfaces dans Pure Basic ?

voila ce que dit l'aide

Les Interfaces sont utilisées pour accéder facilement aux modules 'Orientés Objets' tels que les bibliothèques COM (Component Object Model) ou DirectX. Ce type de bibliothèques sont de plus en plus courantes sous Windows et les interfaces permettent une exploitation de ces fonctions sans impacts de performances. Les interfaces jettent aussi les bases pour une 'Programmation Orientée Object' (OOP en anglais) avec PureBasic mais nécessite de solides connaissances pour en tirer parti (les interfaces n'ont pas été concu pour ajouter une couche objet à PureBasic mais plutot pour accéder facilement à des objets dejà concus). La plupart des interfaces utilisées sous Windows sont déjà incluses dans les fichiers residents 'Interfaces.res' et 'InterfaceDX.res', ce qui rend leur utilisation immédiate.

Le paramètre optionnel Extends permet d'etendre une interface sans avoir a dupliquer ses fonctions (ces 'fonctions' sont aussi communément appelées 'méthodes' des les autres langages objet tel que C++ ou Java). Toutes les fonctions contenues dans l'interface etendue seront disponibles dans la nouvelle interface. C'est utile pour un heritage simple d'objets.

La commande SizeOf peut etre utilisée avec les interfaces pour déterminer la taille d'une interface et la commande OffsetOf peut etre utiliser pour déterminer l'index d'une fonction dans une interface.

Note: Les concepts objets sont principalement appropriés aux développeurs expérimentés et il n'est pas nécessaire de les maitriser ou meme les comprendre pour realiser des applications ou jeux professionnels

En clair , si tu ne comprends pas , c'est que tu n'en as pas besoin

PureBasic

comment utiliser les commandes "Interface/EndInterface&

comment utiliser les commandes "Interface/EndInterface&