1. #1
    Membre régulier
    Homme Profil pro
    Inscrit en
    février 2013
    Messages
    34
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations forums :
    Inscription : février 2013
    Messages : 34
    Points : 86
    Points
    86

    Par défaut Différencier la construction de l'initialisation

    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.

  2. #2
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2011
    Messages
    3 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : Sénégal

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2011
    Messages : 3 147
    Points : 11 648
    Points
    11 648
    Billets dans le blog
    5

    Par défaut

    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.
    Dictionnaire le Littré

  3. #3
    Expert éminent sénior
    Avatar de Paul TOTH
    Homme Profil pro
    Freelance
    Inscrit en
    novembre 2002
    Messages
    6 886
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Freelance
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : novembre 2002
    Messages : 6 886
    Points : 22 111
    Points
    22 111

    Par défaut

    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.
    Developpez.com: Mes articles, forum FlashPascal
    Entreprise: Execute SARL
    Produits : UPnP, RemoteOffice, FlashPascal

  4. #4
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2011
    Messages
    3 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : Sénégal

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2011
    Messages : 3 147
    Points : 11 648
    Points
    11 648
    Billets dans le blog
    5

    Par défaut

    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/

  5. #5
    Membre régulier
    Homme Profil pro
    Inscrit en
    février 2013
    Messages
    34
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations forums :
    Inscription : février 2013
    Messages : 34
    Points : 86
    Points
    86

    Par défaut

    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.

  6. #6
    Responsable Pascal, Delphi et Assembleur


    Avatar de Alcatîz
    Homme Profil pro
    Ressources humaines
    Inscrit en
    mars 2003
    Messages
    7 459
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 51
    Localisation : Belgique

    Informations professionnelles :
    Activité : Ressources humaines
    Secteur : Service public

    Informations forums :
    Inscription : mars 2003
    Messages : 7 459
    Points : 52 561
    Points
    52 561
    Billets dans le blog
    2

    Par défaut

    Bonjour,

    Citation Envoyé par Pierre le Grand Voir le message
    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.

    Règles du forum
    Cours et tutoriels Pascal, Delphi, Lazarus et Assembleur
    Avant de poser une question, consultez les FAQ Pascal, Delphi, Lazarus et Assembleur
    Mes tutoriels et sources Pascal

    Le problème en ce bas monde est que les imbéciles sont sûrs d'eux et fiers comme des coqs de basse cour, alors que les gens intelligents sont emplis de doute. [Bertrand Russell]

  7. #7
    Membre régulier
    Homme Profil pro
    Inscrit en
    février 2013
    Messages
    34
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations forums :
    Inscription : février 2013
    Messages : 34
    Points : 86
    Points
    86

    Par défaut

    Citation Envoyé par Alcatîz Voir le message
    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;

  8. #8
    Expert éminent sénior
    Avatar de Paul TOTH
    Homme Profil pro
    Freelance
    Inscrit en
    novembre 2002
    Messages
    6 886
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Freelance
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : novembre 2002
    Messages : 6 886
    Points : 22 111
    Points
    22 111

    Par défaut

    Citation Envoyé par Pierre le Grand Voir le message
    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
    Developpez.com: Mes articles, forum FlashPascal
    Entreprise: Execute SARL
    Produits : UPnP, RemoteOffice, FlashPascal

  9. #9
    Membre régulier
    Homme Profil pro
    Inscrit en
    février 2013
    Messages
    34
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations forums :
    Inscription : février 2013
    Messages : 34
    Points : 86
    Points
    86

    Par défaut

    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.

  10. #10
    Expert confirmé
    Avatar de anapurna
    Homme Profil pro
    Développeur informatique
    Inscrit en
    mai 2002
    Messages
    2 563
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2002
    Messages : 2 563
    Points : 4 062
    Points
    4 062

    Par défaut

    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.
    Nous souhaitons la vérité et nous trouvons qu'incertitude. [...]
    Nous sommes incapables de ne pas souhaiter la vérité et le bonheur, et sommes incapables ni de certitude ni de bonheur.
    Blaise Pascal
    PS : n'oubliez pas le tag

  11. #11
    Membre régulier
    Homme Profil pro
    Inscrit en
    février 2013
    Messages
    34
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations forums :
    Inscription : février 2013
    Messages : 34
    Points : 86
    Points
    86

    Par défaut

    Citation Envoyé par anapurna Voir le message
    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.

  12. #12
    Expert confirmé
    Avatar de anapurna
    Homme Profil pro
    Développeur informatique
    Inscrit en
    mai 2002
    Messages
    2 563
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2002
    Messages : 2 563
    Points : 4 062
    Points
    4 062

    Par défaut

    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.
    Nous souhaitons la vérité et nous trouvons qu'incertitude. [...]
    Nous sommes incapables de ne pas souhaiter la vérité et le bonheur, et sommes incapables ni de certitude ni de bonheur.
    Blaise Pascal
    PS : n'oubliez pas le tag

  13. #13
    Membre régulier
    Homme Profil pro
    Inscrit en
    février 2013
    Messages
    34
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations forums :
    Inscription : février 2013
    Messages : 34
    Points : 86
    Points
    86

    Par défaut

    Citation Envoyé par anapurna Voir le message
    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.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 6
    Dernier message: 18/05/2007, 11h55
  2. [JBuilder 7] Construction d'executable natif
    Par renaudfaucon dans le forum JBuilder
    Réponses: 3
    Dernier message: 24/11/2006, 22h28
  3. [servlet] initialisation d'objets
    Par tiPouick dans le forum Servlets/JSP
    Réponses: 11
    Dernier message: 05/08/2003, 12h12
  4. Initialisation de XMLModule
    Par Sylvain Leray dans le forum XMLRAD
    Réponses: 10
    Dernier message: 01/04/2003, 10h08
  5. initialisation Directinput avec delphi
    Par Madmaxx dans le forum DirectX
    Réponses: 1
    Dernier message: 21/02/2003, 17h37

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo