Différencier la construction de l'initialisation

Version imprimable

Code:

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.

17/12/2017, 09h02
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. :)

Citation:

Envoyé par Littré

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.

:arrow: Dictionnaire le Littré

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:

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.

17/12/2017, 15h40
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/
17/12/2017, 17h04
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.
17/12/2017, 17h17
Alcatîz

Bonjour,

Citation:

Envoyé par Pierre le Grand

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.

;)

Citation:

Envoyé par Alcatîz

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:

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;

Citation:
Envoyé par Pierre le Grand
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:

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:

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

21/12/2017, 20h18
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.
22/12/2017, 11h18
anapurna
Salut

Depuis Delphi 2007 cela est autorisé :
Code:

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.
24/12/2017, 03h06
Pierre le Grand
Citation:
Envoyé par anapurna

salut

depuis Delphi 2007 cela est autorisé

Code:

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.

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:

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.

Citation:
Envoyé par 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:

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:

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.