FAQ PascalConsultez toutes les FAQ

Une propriété est avant tout un moyen d’accéder à un champ. Cependant, une propriété peut manipuler des méthodes permettant de récupérer une valeur (getter) ou de la fixer (setter).

Les propriétés se servent des mots réservés read et writepour ces accès. Par ailleurs, elles sont déclarées avec l'autre mot réservé property.

Exemple :

1
2
3
4
5
6
7
8
type 
  TMyClass: class 
  private 
     fMyField: Integer; 
     procedure SetMyField(const AInt: Integer); 
  public 
     MyProperty: Integer read fMyField write SetMyField; 
 end;

Si aucune visibilité n'est déclarée dans une classe, c'est la directive public qui est active.

Soient deux classes déclarées comme suit :

1
2
3
4
5
6
7
8
9
10
type 
  
  TMyClass = class 
  public 
    fMyField: Integer; 
  end;   
  
 TMyOtherClass = class 
   fMyField: Integer; 
  end;

Un getter est une méthode qui permet de savoir quelles opérations effectuer lorsqu'une tentative de lecture d'une propriété est faite.
Un setter est au contraire une méthode appelée lorsqu'une propriété doit être écrite.

1
2
3
4
5
6
7
8
9
type 
  TMyClass = class 
  strict private 
    fMyField : string; 
    function GetMyField: string; 
    procedure SetMyField(const AValue: string); 
  public 
    property MyField: string read GetMyField write SetMyField; 
  end;

Contrairement à une variable, une propriété n'occupe pas forcément d'espace en mémoire, car elle n'est pas forcément en rapport avec un champ interne.

On peut par exemple imaginer une propriété en lecture seule qui renverrait un entier tiré au hasard :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
TMyClass = class 
strict private 
  function GetMyProp: Integer; 
published 
  property MyProp: Integer read GetMyProp; 
end; 
// […] 
implementation 
  
function TMyClass.GetMyProp: Integer; 
// *** renvoie un entier de 0 à 99 *** 
begin 
  Result := Random(100); 
end;

Le spécificateur stored précise si la valeur d'une propriété publiée sera stockée dans le flux de la classe. Il est suivi d'un booléen obtenu grâce à une constante, une fonction sans paramètre ou un champ de la classe. Si elle n'est pas précisée, sa valeur présumée est True.

1
2
3
4
5
6
7
8
type 
  
  TMyClass = class 
  [...] 
  published 
    property MyImage: TImage read fImage write SetImage stored False; 
  [...] 
  end;

Le spécificateur default indique quelle valeur par défaut sera utilisée pour la propriété concernée et qu'il n'est par conséquent pas nécessaire de la stocker dans le flux de la classe. Il prend comme paramètre une constante du même type que la propriété et n'est autorisé que pour les types scalaires et les ensembles.

1
2
3
4
5
6
TMyClass = class  
  [...]  
  published  
    property MyProp : Integer read fMyProp write SetMyProp default 100; 
  [...]  
  end;

Le spécificateur nodefault redéfinit une valeur de propriété marquée default sans spécifier de nouvelle valeur. Il est donc utilisé dans une classe descendant d'une classe ayant défini une valeur par défaut pour une propriété particulière.

1
2
3
4
5
6
7
8
9
10
11
12
13
MyClass = class   
  [...]   
  published   
    property MyProp : Integer read fMyProp write SetMyProp default 100;  
  [...]   
  end; 
  
MySubClass = class(TMyClass)   
  [...]   
  published   
    property MyProp : Integer read fMyProp write SetMyProp nodefault;  
  [...]   
  end;

Lors de la définition d’une sous-classe, une propriété peut de nouveau être déclarée sans en préciser le type. Il est ainsi possible de modifier sa visibilité ou ses spécificateurs : par exemple, une propriété déclarée comme protégée sera de nouveau déclarée dans la section publique ou publiée d’une classe enfant.

Cette technique est très utilisée par des classes qui servent de moules à leurs descendants. Ainsi, le composant TLabel qui est proposé par l’unité stdctrls a-t-il cette déclaration :

1
2
3
4
5
6
7
8
9
10
11
{ TLabel } 
  
  TLabel = class(TCustomLabel) 
  published 
    property Align; 
    property Alignment; 
    property Anchors; 
    property AutoSize; 
    property BidiMode; 
    property BorderSpacing; 
    property Caption;

Il est possible de lire et d’écrire plusieurs propriétés à partir d’une même méthode à condition qu’elles soient du même type. Dans ce cas, chaque déclaration de type de propriété sera suivie de la directive index elle-même suivie d’un entier précisant le rang de l’index.

Voici la définition possible d'une classe représentant un rectangle :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
type 
  
  { TMyRect } 
  
  TMyRect = class 
  strict private 
    fValues: array[0..3] of Integer; 
    function GetValue(AIndex: Integer): Integer; 
    procedure SetValue(AIndex: Integer; AValue: Integer); 
  public 
    property Left: Integer index 0 read GetValue write SetValue; 
    property Top: Integer index 1 read GetValue write SetValue; 
    property Width: Integer index 2 read GetValue write SetValue; 
    property Height: Integer index 3 read GetValue write SetValue; 
  end;

1
2
3
4
5
6
7
8
9
10
11
12
13
{ TMyRect } 
  
function TMyRect.GetValue(AIndex: Integer): Integer; 
// *** récupération d'une valeur *** 
begin 
  Result := fValues[AIndex]; 
end; 
  
procedure TMyRect.SetValue(AIndex: Integer; AValue: Integer); 
// *** établissement d'une valeur *** 
begin 
  fValues[AIndex] := AValue; 
end;