comment utiliser les commandes "Interface/EndInterface&

Silver · Message par **Silver** » mer. 28/avr./2004 13:23

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 !

ZapMan · Message par **ZapMan** » jeu. 29/avr./2004 13:48

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)

Chris · Message par **Chris** » jeu. 29/avr./2004 13:52

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

Flype · Message par **Flype** » ven. 30/avr./2004 20:02

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é

Flype · Message par **Flype** » ven. 30/avr./2004 23:01

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.

Flype · Message par **Flype** » ven. 30/avr./2004 23:08

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 )

Silver · Message par **Silver** » sam. 01/mai/2004 11:56

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

nico · Message par **nico** » sam. 01/mai/2004 12:07

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 ?

Flype · Message par **Flype** » sam. 01/mai/2004 13:55

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.

cederavic · Message par **cederavic** » sam. 01/mai/2004 13:59

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

Flype · Message par **Flype** » sam. 01/mai/2004 14:08

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

cederavic · Message par **cederavic** » sam. 01/mai/2004 14:26

comme les class en cpp, bocoup plus intuitif

KarLKoX · Message par **KarLKoX** » sam. 01/mai/2004 17:15

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++

nico · Message par **nico** » sam. 01/mai/2004 18:22

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

comtois · Message par **comtois** » sam. 01/mai/2004 18:26

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