Type. Définition d'un constructeur d'un objet d'un type en un objet du type courant.
Définition du corps d'un constructeur d'un objet d'un type.
Constructeur ( ListeDeParametresDUnAppel )
TypeAcces Constructeur NomDUnType ( ListeDeParametresDUnAppel )
CorpsDUneProcedureOuDUneFonction
Fin Constructeur
Constructeur permet de déclarer une méthode spéciale dont le but est de construire un objet du type en cours de définition à partir d'un ou plusieurs objets. Cette construction engendre la création d'un nouvel objet du type courant dont l'initialisation des propriétés est à la charge de la méthode définie par l'instruction Constructeur.
Le constructeur n'alloue pas l'objet, il ne fait que l'initialiser d'une manière particulière. L'allocation de l'objet est réalisée par la méthode Allouer.
Pour chaque, il peut exister un constructeur implicite utilisé lors de la déclaration d'un objet de ce type. L'effet du constructeur implicite a pour effet d'initialiser chaque propriété à la valeur par défaut de son type. Ce constructeur implicite se déclare par Constructeur().
Si le constructeur implicite n'est pas déclaré, toutes les variables et tous les propriétés de ce type doivent être déclarés en Nul Ou.
La définition par défaut du constructeur implicite peut être surchargée.
Pour les types paramétrés, les constructeurs possèdent des premiers paramètres implicites identiques aux paramètres du type.
Cette méthode est automatiquement synchronisée par une déclaration implicite de l'inflexion Synchroniser. L'accès aux propriétés de l'objet est direct, ce qui permet d'améliorer nettement les performances.
Type A
/*****/
C1 : Entier;
C2 : Reel;
Constructeur(P1 : Entier);
Fin Type
/* Le type A possède un constructeur explicite mais pas de constructeur implicite. */
Type B
/*****/
C3 : Date;
C4 : Fichier;
C5 : ReferenceDe Nul Ou A;
Constructeur();
Constructeur(P1 : A);
Fin Type
/* Un constructeur implicite est défini pour B. */
Type C(P1 : Entier, P2 : Enumere, P3 : Type)
/******************************************/
C6 : Entier;
C7 : Date;
Constructeur();
Fin Type
/* C possède un constructeur sans paramètre. Il n'est pas implicite comme le type possède trois paramètres. */
Constructeur A(P1 : Entier)
/*************************/
/* Corps du constructeur de A. */
...
Fin Constructeur
Constructeur C(P1 : Entier, P2 : Enumere, P3 : Type)
/**************************************************/
/* Corps du constructeur de C. */
...
Fin Constructeur
Variable
/******/
V1 : Nul Ou A;
/* V1 doit accepter Nul du fait de l'abscence de constructeur implicite pour le type A. */
V2 : B;
/* V2 est automatiquement initialisée. */
V3 : Nul Ou C(2,Booleen,Caractere);
/* V3 est de type C qui a trois paramètres. */
Principal
/*******/
Debut
V1=A(10);
/* Construction de V1. */
V2=B(V1);
/* Construction de V2. La valeur d'initialisation ne sert a rien en ce cas. */
V3=C(2,Booleen,Caractere);
/* Construction de V3. */
Fin Principal
| - | - | - | - | - | - | - | - | - |