PureBasic

Étant donnée que je me pose sans arrêt des questions sur la structure final de la POO (qui est essentiel d'après moi pour une question d'organisation) sur chronos http://www.purebasic.fr/french/viewtopic.php?t=8840 j'aimerais avoir une certaine opinion sur les notions essentielle sans alourdir PB.

Pour les novices je vous invite a faire un tour sur http://fr.wikipedia.org/wiki/Orient%C3%A9_objet.

Donc Pour l'instant le précompilateur supporte plus ou moins :
-L'héritage
-Polymorphisme (en partie seulement)

pas de porté spécifique pour les variables elle sont toutes Public

actuellement on une classe se définit ainsi

Code : Tout sélectionner

Class MaClasse [Extends Pere]
   Structure
      Atribut.Type
   EndStructure

   Procedure MaClasse() ;constructeur sensible a la case
      *this\Atribut = chose
   EndProcedure

   Procedure Test()
      debug *this\Atribut
   EndProcedure
EndClass

on utilise une classe comme sa

Code : Tout sélectionner

   Declare *object.MaClasse = New MaClasse();un object doit etre un pointeur
   *object.Test() ; methode test() insensible a la case
   *object\Atribut.MethodeDeLaClasseType()

Je pense a ajouter les macro fonctionnant de la même manière que les procédure et les méthodes statique

Code : Tout sélectionner

Class MaClass
   StaticProcedure test()
      ;pas de *this c'est une méthode statique qui dépend de la classe pas d'un objet
   EndStaticProcedure
EndClass

que l'on utilisera ainsi

Code : Tout sélectionner

MaClass::test()

Je pense aussi ajouter des paramètres par défaut pour les attribut de la classe ex :

Code : Tout sélectionner

Class...
   Atribut.Type = New Type()
   Atribut2.b = 2
....

Code : Tout sélectionner

Class...
   Procedure test(chose.type)
   ...
   EndProcedure

   Procedure test(chose.type, chose2.type)

   EndPorcedure

des suggestion, des idées ?

il y a un tutor très complet sur la poo à cette adresse
et en français, de surcroit... sisi

http://drac.site.chez-alice.fr/Tutorial ... ls.htm#POO

; OOP
;
; A set of instructions to equip PureBasic with
; OOP concepts. It is a possible implementation
; allowing basic concepts as:
; - instanciation,
; - encapsulation,
; - simple inheritance,
; - overload,
; - abstract/concret Classes,
; - composition/agregation.
;

pat

c'est pas un tuto sur la POO que je cherche (j'en ai assez bouffé en cour ^^'), si j'en suis a faire un précompilateur c'est essentiellement car la version POO sur pure en macro ne me satisfait pas en partie car les interfaces c'est assez lourd. J'aimerais juste savoir ce que vous pensez de la structure que j'ai décidé d'adopter (en espérant ne pas défigurer le PB) si vous avez des idées ou autre.

J'en avais fait un aussi :
plus similaire au c++ par contre.

http://www.purebasic.fr/french/viewtopi ... hlight=poo

MaClass::test()

Je ne comprends par pourquoi tu peut utilisé directement une méthode sans passer par un objet.

je vois plus dans ce sens :

Class MaClass
StaticProcedure test()
;pas de *this c'est une méthode statique qui dépend de la classe pas d'un objet
EndStaticProcedure
EndClass

Objet.Maclass
Objet\test()

StaticProcedure

"method" n'est pas plus approprié ?

Abuse des macros pour ton précompilateur , utilise aussi "extends" "structureunion" pour faire vraiment de la poo

Bon courage !

C'est plutôt pas mal au niveau de l'utilisation, le structureunion a clairement sa place comme l'a dit notre Capitaine

Le truc que j'aurais bien aimé avoir c'est la généricité (classe générique en C#/Java, Template en C++) histoire d'ajouter un niveau d'abstraction supplémentaire.

Cpl.Bator a écrit :J'en avais fait un aussi :
plus similaire au c++ par contre.

http://www.purebasic.fr/french/viewtopi ... hlight=poo

Oui j'avais vue sa c'est sympa mais après on s'éloigne beaucoup de la structure du BASIC.

Cpl.Bator a écrit :
MaClass::test()

Je ne comprends par pourquoi tu peut utilisé directement une méthode sans passer par un objet.

je vois plus dans ce sens :

Class MaClass
StaticProcedure test()
;pas de *this c'est une méthode statique qui dépend de la classe pas d'un objet
EndStaticProcedure
EndClass

Objet.Maclass
Objet\test()

StaticProcedure
"method" n'est pas plus approprié ?

En fait une méthode statique ne dépend pas d'un objet mais de la classe, en C++ je pense pas que cela existe par contre en JAVA on en abuse.

Par exemple une classe Math
la classe ne possède aucun attribut mais plein de méthode comme :
sqrt(eniter)
pow(entier, entier)
aucun attribut ? alors pourquoi faire une instance ?
c'est pourquoi on définit les méthodes en statique
Math::sqrt(entier, entier)

pourquoi faire une classe en pure on peut faire des procédures pour remplacer sa ?
juste pour avoir un code ne comportant que des classes ce qui permet de coder avec un diagramme de classe
http://fr.wikipedia.org/wiki/Unified_Modeling_Language

après pour la syntaxe Methode ou Procedure :s j'hésite encore

Cpl.Bator a écrit : Abuse des macros pour ton précompilateur , utilise aussi "extends" "structureunion" pour faire vraiment de la poo

oui je veut un code optimisé alors un constructeur ou je fait qu'allouer de la mémoire inutile d'en faire une procédure par exemple.

Ou encore pourquoi pas des warpers optimisé :

Code : Tout sélectionner

Class Math
   DeclareMethod ACos(Nombre.f) AS ACos(Nombre)
EndClass

Math::Acos(5)


Class Sprite
  DeclareMethod NewSprite(...) AS createsprite(#pb_any, ...)
  DeclareMethod DisplaySprite(..) As DisplaySprite(..)
EndClass

*monsprite.Sprite = New Sprite(...)
*monsprite.DisplaySprite(..) ;deviendra  DisplaySprite(*monsprite, ..) une fois compilé

KarLKoX a écrit :C'est plutôt pas mal au niveau de l'utilisation, le structureunion a clairement sa place comme l'a dit notre Capitaine
Le truc que j'aurais bien aimé avoir c'est la généricité (classe générique en C#/Java, Template en C++) histoire d'ajouter un niveau d'abstraction supplémentaire.

j'ai pensé a la généricité mais je n'ai pas retenue cette idée pour des raisons techniques et je vient de calculer que avec structure Union c'est peut être possible l'ennuie viendra peut être du passage de paramètre d'une méthode ex mamethode(generique.E, nongenerique.type).

Dans tout les cas il faudra les sources de la classe pour utiliser une classe avec la généricité, donc pas de lib statique.

j'ai recupérer un delphi 6 pour voir comment était fait le canvas, les rebars etc..., c'est tout programmé avec des "object"

est ce que ton code pourrait "accélerer" / "faciliter" l'adaptation à purebasic ?

pat

tu peut développer ? je n'ai jamais fait de pascal. cependant la POO c'est juste un habillage on peut coder en procédural de même manière que en POO c'est juste beaucoup moins pratique .

bin ça ressemble à ça

Code : Tout sélectionner

  TCanvas = class(TPersistent)
  private
    FHandle: HDC;
    State: TCanvasState;
    FFont: TFont;
    FPen: TPen;
    FBrush: TBrush;
    FPenPos: TPoint;
    FCopyMode: TCopyMode;
    FOnChange: TNotifyEvent;
    FOnChanging: TNotifyEvent;
    FTextFlags: Longint;
    procedure CreateBrush;
    procedure CreateFont;
    procedure CreatePen;
    procedure BrushChanged(ABrush: TObject);
    procedure DeselectHandles;
    function GetCanvasOrientation: TCanvasOrientation;
    function GetClipRect: TRect;
    function GetHandle: HDC;
    function GetPenPos: TPoint;
    function GetPixel(X, Y: Integer): TColor;
    procedure FontChanged(AFont: TObject);
    procedure PenChanged(APen: TObject);
    procedure SetBrush(Value: TBrush);
    procedure SetFont(Value: TFont);
    procedure SetHandle(Value: HDC);
    procedure SetPen(Value: TPen);
    procedure SetPenPos(Value: TPoint);
    procedure SetPixel(X, Y: Integer; Value: TColor);
  protected
    procedure Changed; virtual;
    procedure Changing; virtual;
    procedure CreateHandle; virtual;
    procedure RequiredState(ReqState: TCanvasState);
  public
    constructor Create;
    destructor Destroy; override;
    procedure Arc(X1, Y1, X2, Y2, X3, Y3, X4, Y4: Integer);
    procedure BrushCopy(const Dest: TRect; Bitmap: TBitmap;
      const Source: TRect; Color: TColor);
    procedure Chord(X1, Y1, X2, Y2, X3, Y3, X4, Y4: Integer);
    procedure CopyRect(const Dest: TRect; Canvas: TCanvas;
      const Source: TRect);
    procedure Draw(X, Y: Integer; Graphic: TGraphic);
    procedure DrawFocusRect(const Rect: TRect);
    procedure Ellipse(X1, Y1, X2, Y2: Integer); overload;
    procedure Ellipse(const Rect: TRect); overload;
    procedure FillRect(const Rect: TRect);
    procedure FloodFill(X, Y: Integer; Color: TColor; FillStyle: TFillStyle);
    procedure FrameRect(const Rect: TRect);
    function HandleAllocated: Boolean;
    procedure LineTo(X, Y: Integer);
    procedure Lock;
    procedure MoveTo(X, Y: Integer);
    procedure Pie(X1, Y1, X2, Y2, X3, Y3, X4, Y4: Integer);
    procedure Polygon(const Points: array of TPoint);
    procedure Polyline(const Points: array of TPoint);
    procedure PolyBezier(const Points: array of TPoint);
    procedure PolyBezierTo(const Points: array of TPoint);
    procedure Rectangle(X1, Y1, X2, Y2: Integer); overload;
    procedure Rectangle(const Rect: TRect); overload;
    procedure Refresh;
    procedure RoundRect(X1, Y1, X2, Y2, X3, Y3: Integer);
    procedure StretchDraw(const Rect: TRect; Graphic: TGraphic);
    function TextExtent(const Text: string): TSize;
    function TextHeight(const Text: string): Integer;
    procedure TextOut(X, Y: Integer; const Text: string);
    procedure TextRect(var Rect: TRect; var Text: string; TextFormat: TTextFormat = []); overload;
    procedure TextRect(Rect: TRect; X, Y: Integer; const Text: string); overload;
    function TextWidth(const Text: string): Integer;
    function TryLock: Boolean;
    procedure Unlock;
    property ClipRect: TRect read GetClipRect;
    property Handle: HDC read GetHandle write SetHandle;
    property CanvasOrientation: TCanvasOrientation read GetCanvasOrientation;
    property PenPos: TPoint read GetPenPos write SetPenPos;
    property Pixels[X, Y: Integer]: TColor read GetPixel write SetPixel;
    property TextFlags: Longint read FTextFlags write FTextFlags;
    property OnChange: TNotifyEvent read FOnChange write FOnChange;
    property OnChanging: TNotifyEvent read FOnChanging write FOnChanging;
  published
    property Brush: TBrush read FBrush write SetBrush;
    property CopyMode: TCopyMode read FCopyMode write FCopyMode default cmSrcCopy;
    property Font: TFont read FFont write SetFont;
    property Pen: TPen read FPen write SetPen;
  end;

et l'implémentation : (extrait)

Code : Tout sélectionner

{ TCanvas }

constructor TCanvas.Create;
begin
  inherited Create;
  FFont := TFont.Create;
  FFont.OnChange := FontChanged;
  FFont.OwnerLock := Self;
  FPen := TPen.Create;
  FPen.OnChange := PenChanged;
  FPen.OwnerLock := Self;
  FBrush := TBrush.Create;
  FBrush.OnChange := BrushChanged;
  FBrush.OwnerLock := Self;
  FCopyMode := cmSrcCopy;
  State := [];
  CanvasList.Add(Self);
end;

destructor TCanvas.Destroy;
begin
  CanvasList.Remove(Self);
  SetHandle(0);
  inherited Destroy;
end;

procedure TCanvas.Arc(X1, Y1, X2, Y2, X3, Y3, X4, Y4: Integer);
begin
  Changing;
  RequiredState([csHandleValid, csPenValid, csBrushValid]);
  Windows.Arc(FHandle, X1, Y1, X2, Y2, X3, Y3, X4, Y4);
  Changed;
end;

Oui effectivement bien que je ne pense pas respecter autant de standard de l'UML que le Pascal Object (langage de Delphi) un des autres intérêt de la POO sous pure est le portage des codes d'un langage a un autre.

bon, euh, meme si tu le fait ça veut pas dire que j'arriverai à convertir un code comme celui là...

pat

Chaos a écrit : pourquoi faire une classe en pure on peut faire des procédures pour remplacer sa ?
juste pour avoir un code ne comportant que des classes ce qui permet de coder avec un diagramme de classe
http://fr.wikipedia.org/wiki/Unified_Modeling_Language

A titre indicatif, le procédural est schématisable.

la POO c'est juste une surcouche du procédural donc c'est normal mais c'est beaucoup moins pratique.

la POO c'est juste une surcouche du procédural donc c'est normal mais c'est beaucoup moins pratique.

Moi je doit encore etre le seul

Tout le monde vente la POO, POO par ci, POO par la

Et je trouve ça beaucoup plus dur a comprendre, et meme plus compliqué a gerer.

Regarde KCC :

MaClass Voiture
{
Poids.f
PuissanceMoteur.f
Accelere()
OuvrePorte()
FaitLePlein()
}

Clio.Voiture

Clio.Poids = 1.1
Clio.PuissanceMoteur = 1.1

Clio.FaitLePlein()
Clio.Accelere()
Clio.OuvrePorte()

Considère la POO comme une grosse "structure" ou tu peut mettre des méthodes ( fonctions ) propre à la classe.
par ex , OuvrePorte() ne fonctionne qu'avec la classe Voiture
si tu as une classe Humain par exemple , tu ne pourra pas faire OuvrePorte() , ca na pas de sens, la Poo sert à rendre la prog plus compréhensible.

PureBasic

La POO version PureBasic

La POO version PureBasic