IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Delphi Discussion :

Overload d'une property


Sujet :

Delphi

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé Avatar de Tchaill39
    Profil pro
    Inscrit en
    Septembre 2005
    Messages
    110
    Détails du profil
    Informations personnelles :
    Localisation : France, Rhône (Rhône Alpes)

    Informations forums :
    Inscription : Septembre 2005
    Messages : 110
    Par défaut Overload d'une property
    Bonjour à tous

    Juste une petite question qui va peut être vous paraitre idiote, mais bon, qui n'apprend pas, ne progresse pas !!!!
    Peux-on dans Delphi faire un overload d'une propriété ? ex :


    Property F[index : Integer] : real read Get_Valeur write Set_Valeur;overload;

    Property F[index : Integer ; Nodent : integer] : real read Get_Valeur_Nodent write Set_Valeur_Nodent;overload;

  2. #2
    Expert éminent
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    14 089
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 14 089
    Par défaut
    Tu ne peux pas faire d'overload, mais plus une sorte d'override ...

    dans une classe A, tu peux avoir la propriété Tata, et dans la Classe B, qui hérite de A, tu peux redéclarer la propriété Tata avec d'autres accesseurs, et tu ne peux accéder à Tata avec les accesseurs de A, avec inherited

    je "surcharge" l'Items de la TList par ceux de la TCraftDataList ...

    Ton besoin ressemble plus à Items et State à la limite, ils faut deux nom, et des accesseurs différents vu les indices différents ...

    exemple

    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
    // Les Structures suivantes ne peuvent pas être utilisé dans un Parçage par Transtypage de Zone Mémoire
    type
      TCraftParserState = (cpsNone, cpsParsed, cpsUsed, cpsToPack, cpsPacked);
      TCraftData = Pointer;
      PCraftEnveloppe = ^TCraftEnveloppe;
      TCraftEnveloppe = record
        DataType: TEnumCraftDataType; // TOleEnumCraftDataType ne Limite pas l'Enumération aux seules constantes, vérification de l'étendue Manuelle
        DataHeader: String; // Contient l'Entete, Craft_HEADER_*
        DataRaw: String; // Contient la Chaine tel que reçu
        Data: TCraftData; // Contient une Structure PCraftPatient, PCraftSejour, ...
        DataList: TStringList; // sous forme de Liste de Chaine
        State: TCraftParserState;
      end;
     
      // Classe Listant les Données d'un Buffer décomposé
      TCraftDataList = class(TList)
      protected
        function GetItem(Index: Integer): TCraftEnveloppe;
        function GetState(Index: Integer): TCraftParserState;
        procedure SetState(Index: Integer; State: TCraftParserState);
      public
        function Add(const CraftEnveloppe: TCraftEnveloppe): Integer;
        procedure Clear; override;
        procedure Delete(Index: Integer);
        procedure Insert(Index: Integer; const CraftEnveloppe: TCraftEnveloppe);
        function First: TCraftEnveloppe;
        function Last: TCraftEnveloppe;
        // Propriétés
        property Items[Index: Integer]: TCraftEnveloppe read GetItem; default;
        property State[Index: Integer]: TCraftParserState read GetState write SetState;
      end;
    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
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    // TCraftDataList ---------------------------------------------------------------
    //                                                                             -
    //                    TCraftDataList - Protected                                -
    //                                                                             -
    // TCraftDataList ---------------------------------------------------------------
     
    // TCraftDataList - Protected ---------------------------------------------------
    function TCraftDataList.GetItem(Index: Integer): TCraftEnveloppe;
    begin
         // On veut une Structure TCraftEnveloppe, et n'ont pas un pointeur, donc déférencement (^)
         Result := TCraftEnveloppe(inherited Items[Index]^);
    end;
     
    // TCraftDataList - Protected ---------------------------------------------------
    function TCraftDataList.GetState(Index: Integer): TCraftParserState;
    begin
         // On veut une Structure TCraftEnveloppe, et n'ont pas un pointeur, donc déférencement (^)
         Result := TCraftEnveloppe(inherited Items[Index]^).State;
    end;
     
    // TCraftDataList - Protected ---------------------------------------------------
    procedure TCraftDataList. SetState(Index: Integer; State: TCraftParserState);
    begin
         // On veut une Structure TCraftEnveloppe, et n'ont pas un pointeur, donc déférencement (^)
         TCraftEnveloppe(inherited Items[Index]^).State := State;
    end;
     
     
    // TCraftDataList ---------------------------------------------------------------
    //                                                                             -
    //                     TCraftDataList - Public                                  -
    //                                                                             -
    // TCraftDataList ---------------------------------------------------------------
     
    // TCraftDataList - Public ------------------------------------------------------
    function TCraftDataList.Add(const CraftEnveloppe: TCraftEnveloppe): Integer;
    var
       TmpCraftEnveloppe: PCraftEnveloppe;
    begin
         New(TmpCraftEnveloppe);
         TmpCraftEnveloppe^.DataType   := CraftEnveloppe.DataType;
         TmpCraftEnveloppe^.DataHeader := CraftEnveloppe.DataHeader;
         TmpCraftEnveloppe^.Data       := CraftEnveloppe.Data;
         TmpCraftEnveloppe^.DataRaw    := CraftEnveloppe.DataRaw;
         TmpCraftEnveloppe^.DataList   := CraftEnveloppe.DataList;
     
         Result := inherited Add(TmpCraftEnveloppe);
    end;
     
    // TCraftDataList - Public ------------------------------------------------------
    procedure TCraftDataList.Clear;
    var
       Index: Integer;
    begin
         for Index := Count - 1 downto 0 do begin
             if Assigned(inherited Items[Index]) then begin
                if Assigned(TCraftEnveloppe(inherited Items[Index]^).Data) then begin
                   Dispose(TCraftEnveloppe( inherited Items[Index]^).Data);
                end;
                if Assigned(TCraftEnveloppe(inherited Items[Index]^).DataList) then begin
                   TCraftEnveloppe(inherited Items[Index]^).DataList.Free();
                   TCraftEnveloppe(inherited Items[Index]^).DataList := nil;
                end;
                Dispose(inherited Items[Index]);
             end;
         end;
     
         inherited Clear();
    end;
     
    // TCraftDataList - Public ------------------------------------------------------
    procedure TCraftDataList.Delete(Index: Integer);
    begin
         Dispose(TCraftEnveloppe(inherited Items[Index]^).Data);
         Dispose(inherited Items[Index]);
     
         inherited Delete(Index);
    end;
     
    // TCraftDataList - Public ------------------------------------------------------
    procedure TCraftDataList.Insert(Index: Integer; const CraftEnveloppe: TCraftEnveloppe);
    var
       TmpCraftEnveloppe: PCraftEnveloppe;
    begin
         New(TmpCraftEnveloppe);
         TmpCraftEnveloppe^.DataType   := CraftEnveloppe.DataType;
         TmpCraftEnveloppe^.DataHeader := CraftEnveloppe.DataHeader;
         TmpCraftEnveloppe^.Data       := CraftEnveloppe.Data;
         TmpCraftEnveloppe^.DataRaw    := CraftEnveloppe.DataRaw;
         TmpCraftEnveloppe^.DataList   := CraftEnveloppe.DataList;
     
         inherited Insert(Index, TmpCraftEnveloppe);
    end;
     
    // TCraftDataList - Public ------------------------------------------------------
    function TCraftDataList.First: TCraftEnveloppe;
    begin
         // On veut une Structure TCraftEnveloppe, et n'ont pas un pointeur, donc déférencement (^)
         Result := TCraftEnveloppe(inherited First^);
    end;
     
    // TCraftDataList - Public ------------------------------------------------------
    function TCraftDataList.Last: TCraftEnveloppe;
    begin
         // On veut une Structure TCraftEnveloppe, et n'ont pas un pointeur, donc déférencement (^)
         Result := TCraftEnveloppe(inherited Last()^);
    end;
    Aide via F1 - FAQ - Guide du développeur Delphi devant un problème - Pensez-y !
    Attention Troll Méchant !
    "Quand un homme a faim, mieux vaut lui apprendre à pêcher que de lui donner un poisson" Confucius
    Mieux vaut se taire et paraître idiot, Que l'ouvrir et de le confirmer !
    L'ignorance n'excuse pas la médiocrité !

    L'expérience, c'est le nom que chacun donne à ses erreurs. (Oscar Wilde)
    Il faut avoir le courage de se tromper et d'apprendre de ses erreurs

Discussions similaires

  1. Properties : comment spécifier les paramètres d'une property ?
    Par guilhemr dans le forum Collection et Stream
    Réponses: 9
    Dernier message: 21/04/2008, 13h57
  2. Réponses: 3
    Dernier message: 21/07/2007, 01h48
  3. Réponses: 2
    Dernier message: 28/05/2007, 09h28
  4. Comment unset une property système
    Par hugo123 dans le forum Langage
    Réponses: 5
    Dernier message: 25/10/2006, 15h29
  5. Mettre une property en virtual
    Par WebPac dans le forum Langage
    Réponses: 11
    Dernier message: 25/10/2004, 14h11

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