Discussion :

[Pierre le Grand]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
VAR
    UneInstance: TMaClasse
 
 
Begin
   UneInstance:= TMaClasse.Create(1); //création
 
   UneInstance.Create(2); //Simple initialisation sans création
End;
 
Constructor TMaClasse.Create(const i: integer);
Begin
 
   IF (quelquechose) THEN //Je cherche quoi mettre dans ce test à la place de «quelquechose»
     RAISE ECetteInstanceNePeutPasEtreInitialiseeDeuxFois.Create('Les instances de TMaClasse sont constantes après la création et ne peuvent pas être modifiées.');
 
   fi:=i;
End;

Existe-il une variable ou une fonction qui permettrait de différencier entre les deux utilisations d'un constructeur?

En C++ le problème ne se poserait même pas par ce qu'un constructeur n'est pas utilisable en tant que fonction normale. Il faut dire que C++ a des siècles d'avance sur Free Pascal dans le domaine des instances constantes par ce que les attributs d'une classe peuvent être déclarées constants et initialisés dans la liste d'initialisation du constructeur et qu'une instance de classe peut être déclarée constante.

[Roland Chastain]

Bonjour !

Je dirais qu'utiliser le constructeur pour une simple initialisation sans création, c'est vouloir lui faire faire autre chose que ce pourquoi il est fait. Moi je ferais une procédure pour l'initialisation. Mais peut-être que je me trompe : les autres le diront.

J'ai changé "différentier" en "différencier", après avoir consulté le Littré, parce que j'avais quand même un doute.

Il ne faut pas confondre différencier, mettre une différence, et différentier, prendre la différentielle (terme de mathématique). Ces deux mots sont les mêmes ; mais l'orthographe les différencie : différence qui d'ailleurs ne s'appuie sur aucune bonne raison.

Dictionnaire le Littré

[Paul TOTH]

En effet, en Pascal le constructeur peut être appelé comme n'importe quelle méthode.

Tous les champs d'un objet étant NULL par défaut, il est facile de distinguer la création d'un appel.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
type
  TMaClasse= class
  private
    alloue: Boolean;
    fi: Integer;
  public
    constructor Create(i: integer);
  end;
 
constructor TMaClasse.Create(i: Integer);
begin
  if alloue then
   raise ECetteInstanceNePeutPasEtreInitialiseeDeuxFois.Create('Les instances de TMaClasse sont constantes après la création et ne peuvent pas être modifiées.');
  alloue := True;
  fi := i;
end;

NB: si "i" ne peut pas avoir la valeur 0 il est également possible de tester sa valeur.

[Roland Chastain]

Un lien vers une autre discussion intéressante à peu près sur le même sujet :

https://www.developpez.net/forums/d1...ique-d-objets/

[Pierre le Grand]

Merci!

J'avais oublié que Free Pascal initialise tous les attributs à NULL contrairement à presque tous les autres langages pour lesquels une variable non initialisée peut contenir n'importe quoi et ne doit jamais être utilisée dans une énoncé IF.

[Alcatîz]

Bonjour,

J'avais oublié que Free Pascal initialise tous les attributs à NULL contrairement à presque tous les autres langages pour lesquels une variable non initialisée peut contenir n'importe quoi et ne doit jamais être utilisée dans une énoncé IF.

... Ce qui n'empêche pas d'avoir le réflexe d'assurer ses arrières. Personnellement, je n'utilise pas une variable sans l'avoir initialisée, et d'autant moins que mon code peut éventuellement être compilé par autre chose que Free Pascal.

[Pierre le Grand]

Ce qui n'empêche pas d'avoir le réflexe d'assurer ses arrières. Personnellement, je n'utilise pas une variable sans l'avoir initialisée, et d'autant moins que mon code peut éventuellement être compilé par autre chose que Free Pascal.

Mais dans ce cas particulier, si on évitait l'utilisation des variables non initialisée, il serait impossible de bloquer l'utilisation du constructeur en tant que simple fonction.

Le vrai problème, c'est que ce qui suit est illégal en Free Pascal.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
 
type
   TMaclasse = class
 
      Private
         const fi: integer;  //Déclaration d'un champ constant dont la valeur ne sera plus modifiable après la fin de l'exécution du constructeur
   End;

[Paul TOTH]

Mais dans ce cas particulier, si on évitait l'utilisation des variables non initialisée, il serait impossible de bloquer l'utilisation du constructeur en tant que simple fonction.

Le vrai problème, c'est que ce qui suit est illégal en Free Pascal.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
 
type
   TMaclasse = class
 
      Private
         const fi: integer;  //Déclaration d'un champ constant dont la valeur ne sera plus modifiable après la fin de l'exécution du constructeur
   End;

le mot clé "const" n'a pas vocation à être ignoré dans un constructor. Il ne faut pas confondre les constructeurs implicites du C++ et les constantes Pascal qui sont immuables (sauf si {$J+} est activé car historiquement une constante typée était une variable initialisée, depuis et par défaut, les constantes typées restent des constantes et il est possible d'initialiser des variables).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
// code pascal historique
var
  i: Integer;
const
  j: Integer = 2; // modifiable
const
  k = 3; // immuable
 
// code Delphi actuel
var
  i: Integer;
const
  j :Integer = 3; // immuable
const
  k = 3; // immuable
var
  l : Integer = 2; // modifiable,  n'était pas possible avant

[Pierre le Grand]

Je sais que depuis au moins Turbo Pascal 3, une constante typée n'est qu'une variable initialisée. Tout comme le C++ moderne a révolutionné ce langage, Pascal ne pourra pas éternellement continuer à exister sans intégrer des concepts modernes comme la création d'une instance constante d'une classe et l'ajout de champs constants dans une classe.

[anapurna]

Salut

Depuis Delphi 2007 cela est autorisé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
TMaclass = Class 
  Public 
    ...
  Private 
     const Etat : integer = 2; // Delphi 2007 
  ....
end;

En Pascal, la constante doit être affectée au moment de sa déclaration.

[Pierre le Grand]

salut

depuis Delphi 2007 cela est autorisé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
TMaclasse = Class 
  Public 
    ...
  Private 
     const Etat : integer = 2; // Delphi 2007 
  ....
end;

C'est légal, mais Etat sera initialisé à 2 dans toutes les instances des TMaClasse ce qui n'est pas l'effet voulu qui est qu'Etat puisse être initialisée une seule fois dans le constructeur à n'importe quelle valeur inconnue au moment de la compilation et demeurer constant par la suite.

[anapurna]

Salut

Donc ce n'est pas une constante que tu veux mais bien une variable. Après, pour éviter la modif de ta valeur, tu peux passer par une classe

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
TIntValue = Class 
Private 
  Fvalue : Integer;
Public
  Constructor Create(MaValeur : Integer);
  Property Value : Integer read  Fvalue;
end; 
 
Constructor TIntValue.Create(MaValeur : Integer);
begin
  Fvalue := MaValeur
end;
 
....
 
type
  TMaClasse= class
  private
     fi: TIntValue;
  public
    constructor Create(i: TIntValue);
  end;
 
constructor TMaClasse.Create(i: integer);
begin
   fi := TIntValue.Create(i);
end;

Vu que la property IntValue n'est pas modifiable après.

[Pierre le Grand]

Salut

Donc ce n'est pas une constante que tu veux mais bien une variable. Après, pour éviter la modif de ta valeur, tu peux passer par une classe

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
TIntValue = Class 
Private 
  Fvalue : Integer;
Public
  Constructor Create(MaValeur : Integer);
  Property Value : Integer read  Fvalue;
end; 
 
Constructor TIntValue.Create(MaValeur : Integer);
begin
  Fvalue := MaValeur
end;
 
....
 
type
  TMaClasse= class
  private
     fi: TIntValue;
  public
    constructor Create(i: TIntValue);
  end;
 
constructor TMaClasse.Create(i: integer);
begin
   fi := TIntValue.Create(i);
end;

Vu que la property IntValue n'est pas modifiable après.

Ce code ne peut pas être compilé par ce que la déclaration constructor Create(i: TIntValue); n'est pas compatible avec l'implémentation constructor TMaClasse.Create(i: integer); . Integer et TIntValue étant deux types distincts. De plus, il n'y a aucune manière d'accéder à la valeur de fi;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
program TestDeConstance;
 
TYPE
 
TIntValue = Class
Private
  Fvalue : Integer;
Public
  Constructor Create(MaValeur : Integer);
  Property Value : Integer read  Fvalue;
end;
 
Constructor TIntValue.Create(MaValeur : Integer);
begin
  Fvalue := MaValeur
end;
 
type
  TMaClasse= class
  private
     fi: TIntValue;
  public
    constructor Create(i: Integer);
    Function Geti: Integer;
  end;
 
constructor TMaClasse.Create(i: integer);
begin
   fi := TIntValue.Create(i);
end;
Function TMaclasse.Geti: Integer;
Begin
   Result:=fi.Value;
end;
 
Var
  X : TMaClasse;
  c: char;
begin
   X:= TMaClasse.Create(4);
   WriteLn(X.Geti);
   X.Create(2); //Modifie fi même sans aucune fonction de modification.
   WriteLn(X.Geti);
 
   ReadLn(c);
   WriteLn(c);
end.

Même après correction, le problème demeure entier. Ajouter un niveau d'indirection n'a pas réglé le problème. La cause du problème, c'est qu'un constructeur en Free Pascal, c'est complètement différent d'un constructeur en C++. C++ nous a habitué à penser qu'un constructeur n'est pas une fonction, mais en Free Pascal, un constructeur est à la fois un constructeur et une fonction. Si aucune précaution particulière n'est prise, ce que le constructeur peut modifier, la fonction du même nom pourra le modifier aussi.

Paul TOTH a complètement résolu le problème.