[D5] Charger rapidement un type record

**MelkInarian** · 03/04/2007, 19h40

Connaissez vous un moyen de charger rapidement un type record (boucle ou boucles imbriquées).
Je m’explique : je souhaite créer un code permettant de gérer (créer, modifier) des feuilles de personnages pour un jeu.
Un personnage représente une multitude de variables (Force, Dextérité ..., Compétences diverses, Classes, niveaux,…).
Pour ce faire j’ai pensé créer un type enregistrement.
Certains de ces enregistrements sont eux-mêmes de type enregistrement qui peuvent être encore de type enregistrement (jusqu’à présent j’ai ainsi 3 niveaux mais je commence juste).
Le premier problème que je sent pointer va être pour la sauvegarde et/ou le chargement de cette structure.
Si par exemple je décidais de charger / sauvegarder toutes ces variables de façon linéaire dans un fichier .TXT, cela parait simple à ouvrir / fermer et incrémenter mais pour alimenter la structure qu’en est-il ?

**Fabrice ROUXEL 1** · 03/04/2007, 20h06

C'est rapide à charger, pas de soucis.
Préféres l'instruction record à packed record. les record compréssés sont plus lent d'accés.

Tu créés 2 fonctions genre RecordDansFichier et FichierDansRecord qui
sauvegarde les données dans un fichier .ini et qui charge par section les données dans les records à l'initialisation de l'application.

**anapurna** · 03/04/2007, 20h10

salut

ah bin la je suis pas d'accord avec le jeune homme parcque
sinon tu vas te retrouve bloquer par des imcompatibilite avec les version precedente ou suivante de delphi

le record n'est pas forcement une bonne solution
un fichier text ne pose pas ce genre d'inconvenient mais il est facilement modifiable

un solution serait de te servir d'un fichier texte compresser
afin que le s donnée ne soit pas disponible directement

@+ Phil

**Fabrice ROUXEL 1** · 03/04/2007, 20h16

Heu... J'ai écrit d'utiliser un record et non un packed record.

Je ne vois pas le probleme d'incompatibilité puisque je précise d'utiliser un record qui lui est compatible mais de proscrire le packed record qui lui ne l'est pas.

**anapurna** · 03/04/2007, 20h24

salut

laisse tomber en plus j'au vu que tu le lit dans un fichier ini et pas dans un fichier de record

@+ Phil

**MelkInarian** · 03/04/2007, 20h26

Fabrice ROUXEL 1 C'est rapide à charger, pas de soucis.
Préféres l'instruction record à packed record. les record compréssés sont plus lent d'accés.
Tu créés 2 fonctions genre RecordDansFichier et FichierDansRecord qui
sauvegarde les données dans un fichier .ini et qui charge par section les données dans les records à l'initialisation de l'application.

Voici une partie de la déclaration.

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
type
  TDon  = Record
    Don1  : ShortString;   // Libellé du 1er don au niveau x
    Don2  : ShortString;   // Libellé du 2ème don au niveau x
    Don3  : ShortString;   // Libellé du 3ème don au niveau x
  end;
 
  TClas = Record
    LibClas : ShortString;   // Libellé de la classe de base
    Niveau  : Shortint;      // Niveau atteint dans la classe de base
    DV      : Byte;          // Dé de vie
    ModRef  : Shortint;      // Modificateur aux jets de Reflexes f(classe1)
    ModVig  : Shortint;      // Modificateur aux jets de Vigueur f(classe1)
    ModVol  : Shortint;      // Modificateur aux jets de Volonté f(classe1)
    M_Att1  : Shortint;      // Modificateur aux jets de 1ère attaque f(classe1)
    M_Att2  : Shortint;      // Modificateur aux jets de 2ème attaque f(classe1)
    M_Att3  : Shortint;      // Modificateur aux jets de 3ème attaque f(classe1)
    M_Att4  : Shortint;      // Modificateur aux jets de 4ème attaque f(classe1)
    M_Att5  : Shortint;      // Modificateur aux jets de 5ème attaque f(classe1)
    M_Att6  : Shortint;      // Modificateur aux jets de 6ème attaque f(classe1)
    M_Att7  : Shortint;      // Modificateur aux jets de 7ème attaque f(classe1)
    M_Att8  : Shortint;      // Modificateur aux jets de 8ème attaque f(classe1)
 
    Don1N01 : TDon;          // 3 Premiers dons au niveau 1
    Don2N01 : TDon;          // 3 dons suivants au niveau 1
    Don1N02 : TDon;          // 3 Premiers dons au niveau 2
    Don1N03 : TDon;          // 3 Premiers dons au niveau 3
    Don1N04 : TDon;          // 3 Premiers dons au niveau 4
    Don1N05 : TDon;          // 3 Premiers dons au niveau 5
    Don1N06 : TDon;          // 3 Premiers dons au niveau 6
    Don1N07 : TDon;          // 3 Premiers dons au niveau 7
    Don1N08 : TDon;          // 3 Premiers dons au niveau 8
    Don1N09 : TDon;          // 3 Premiers dons au niveau 9
    Don1N10 : TDon;          // 3 Premiers dons au niveau 10
    Don1N11 : TDon;          // 3 Premiers dons au niveau 11
    Don1N12 : TDon;          // 3 Premiers dons au niveau 12
    Don1N13 : TDon;          // 3 Premiers dons au niveau 13
    Don1N14 : TDon;          // 3 Premiers dons au niveau 14
    Don1N15 : TDon;          // 3 Premiers dons au niveau 15
    Don1N16 : TDon;          // 3 Premiers dons au niveau 16
    Don1N17 : TDon;          // 3 Premiers dons au niveau 17
    Don1N18 : TDon;          // 3 Premiers dons au niveau 18
    Don1N19 : TDon;          // 3 Premiers dons au niveau 19
    Don1N20 : TDon;          // 3 Premiers dons au niveau 20
    Don1N21 : TDon;          // 3 Premiers dons au niveau 21
    Don1N22 : TDon;          // 3 Premiers dons au niveau 22
    Don1N23 : TDon;          // 3 Premiers dons au niveau 23
    Don1N24 : TDon;          // 3 Premiers dons au niveau 24
    Don1N25 : TDon;          // 3 Premiers dons au niveau 25
    Don1N26 : TDon;          // 3 Premiers dons au niveau 26
    Don1N27 : TDon;          // 3 Premiers dons au niveau 27
    Don1N28 : TDon;          // 3 Premiers dons au niveau 28
    Don1N29 : TDon;          // 3 Premiers dons au niveau 29
    Don1N30 : TDon;          // 3 Premiers dons au niveau 30
    Don1N31 : TDon;          // 3 Premiers dons au niveau 31
    Don1N32 : TDon;          // 3 Premiers dons au niveau 32
    Don1N33 : TDon;          // 3 Premiers dons au niveau 33
    Don1N34 : TDon;          // 3 Premiers dons au niveau 34
    Don1N35 : TDon;          // 3 Premiers dons au niveau 35
    Don1N36 : TDon;          // 3 Premiers dons au niveau 36
    Don1N37 : TDon;          // 3 Premiers dons au niveau 37
    Don1N38 : TDon;          // 3 Premiers dons au niveau 38
    Don1N39 : TDon;          // 3 Premiers dons au niveau 39
    Don1N40 : TDon;          // 3 Premiers dons au niveau 40
  end;
 
  Tpnj = record
    Race    : ShortString;   // Libellé de la race
    RCTail  : ShortString;   // Catégorie de taille
    RMFor   : Shortint;      // Modificateur Racial de Force
    RMDex   : Shortint;      // Modificateur Racial de Dextérité
    RMCon   : Shortint;      // Modificateur Racial de Constitution
    RMInt   : Shortint;      // Modificateur Racial d'Intelligence
    RMSag   : Shortint;      // Modificateur Racial de Sagesse
    RMCha   : Shortint;      // Modificateur Racial de Charisme
    RClPred : ShortString;   // Classe de prédilection f(race)
    RVDpltM : Shortint;      // Vitesse de déplacement de Base en mètres
    RVDpltC : Shortint;      // Vitesse de déplacement de Base en cases
    RDonSup : Boolean;       // Don supplémentaire f(race)
    RPCpSup : Shortint;      // Points de compétances supplémentaire f(race)
    RLang_1 : ShortString;   // 1ère langue parlée f(race)
    RLang_2 : ShortString;   // 2ème langue parlée f(race)
    Lang_3  : ShortString;   // 3ème langue parlée f(intelligence)
    Lang_4  : ShortString;   // 4ème langue parlée f(intelligence)
    Lang_5  : ShortString;   // 5ème langue parlée f(intelligence)
    Lang_6  : ShortString;   // 6ème langue parlée f(intelligence)
    RVisNct : Boolean;       // Vision Nocturne;
    RVisNoir: Shortint;      // Vision dans le noir en m
    RMAttV  : Shortint;      // Valeur du modificateur racial aux jets d'attaque.
    RMAttR  : ShortString;   // Liste des races pénalisées par le racial aux jets d'attaque.
    RMPoids : Shortint;      // Modificateur racial de poids porté % par rapport à taille M
    RMRef   : Shortint;      // Modificateur racial aux jets de Reflexes
    RMVig   : Shortint;      // Modificateur racial aux jets de Vigueur
    RMVol   : Shortint;      // Modificateur racial aux jets de Volonté
 
    Clas_1  : TClas;         // Classe de base
    Clas_2  : TClas;         // 2ème Classe
    Clas_3  : TClas;         // 3ème Classe
    Clas_4  : TClas;         // 4ème Classe
 
    NivGlob : Shortint;      // Niveau global atteint = somme des niveaux de chaque classe
    LimCC   : Shortint;      // Niveau limite des compétences de classe = Niveau global + 3
    LimHC   : Shortint;      // Niveau limite des compétences hors classe = Niveau global + 3 / 2
end;

Là ou je ne vois pas comment faire c'est justement pour charger ma structure!
Si j'écris par exemple:

Code :

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

1
2
3
4
5
 Var
MonPNJ : Tpnj;
  Cptr1, Cptr2, Cptr3 : Integer;
  For Cptr1 := 0 to X do
     MonPNJ[Cptr1] := MavariableChargée[Cptr1].Value

C'est pas glop.

**MelkInarian** · 04/04/2007, 09h55

Envoyé par Fabrice ROUXEL 1

J'ai mis une unité en piece jointe pour que tu puisses voir le principe.
Elle n'est pas achevée.

Merci pour la démonstration d'utilisation de fichier .ini.
Je déduis de l'énumération qu'on ne peut pas le faire au moyen de boucles et d'index. C'est donc résolu pour moi.
Merci encore pour le temps passé à écrire cette longue série d'affectations.

**ShaiLeTroll** · 04/04/2007, 15h22

Sinon, encore plus simple !

Tu déclare un TComponent, tu mets tes propriétés en published (avec valeur par default par prudence) et utilise ces fonctions issus de l'aide de Delphi !

Et cela permet de gérer en plus facile l'évolution des objets (l'ajout de propriétés, la suppression étant à éviter au possible)

Ces fonctions manipulent des chaines que tu peux lire et écrire dans un fichier, et c'est ni plus ni moins des DFM !!!

voilà Standard Delphi !

Ah, oui faut penser à faire un RegisterClasses() des classes TPNJ et autres ...

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
function ComponentToString(Component: TComponent): string;
var
  BinStream:TMemoryStream;
  StrStream: TStringStream;
  s: string;
begin
  BinStream := TMemoryStream.Create;
  try
    StrStream := TStringStream.Create(s);
    try
      BinStream.WriteComponent(Component);
      BinStream.Seek(0, soFromBeginning);
      ObjectBinaryToText(BinStream, StrStream);
      StrStream.Seek(0, soFromBeginning);
      Result:= StrStream.DataString;
    finally
      StrStream.Free;
    end;
  finally
    BinStream.Free
  end;
end;
 
function StringToComponent(Value: string): TComponent;
var
  StrStream:TStringStream;
  BinStream: TMemoryStream;
begin
  StrStream := TStringStream.Create(Value);
  try
    BinStream := TMemoryStream.Create;
    try
      ObjectTextToBinary(StrStream, BinStream);
      BinStream.Seek(0, soFromBeginning);
      Result := BinStream.ReadComponent(nil);
    finally
      BinStream.Free;
    end;
  finally
    StrStream.Free;
  end;
end;

Sinon, la solution du Packed Record, et du File of Record, est tout à fait utilisable, il faut juste gérer un entête pour la version et conserver dans une unité l'historique des versions des structures pour la migration, juste un peu rigueur c'est tout !

ah oui Packed <> compressé, c'est juste "non aligné en mémoire" cela n'a rien à voir et c'est ainsi compatible avec les structures C !

**Fabrice ROUXEL 1** · 04/04/2007, 16h56

Salut MelkInarian

Je déduis de l'énumération qu'on ne peut pas le faire au moyen de boucles et d'index.

Si tu presentes au joueur une fiche de competences du PNJ qu'il doit renseigner à la main, de toutes facon je ne vois pas sur quels criteres tu boucleras.
Les affectations il faudra bien les écrire à un moment.Tu peux chercher dans la vcl il n'y a aucune fonction qui t'y aidera.

Sinon, il y a d'autres facon de procéder.
Utiliser les fichiers à accés séquentiels (non direct) ou bien les fichiers binaires sachant pour ces derniers que tu devras coder les procedures de lecture/Ecritures.

Maintenant, si le PNJ evolue dans un environnement 2D/3D/3D isometrique et que tu dois le manipuler etc, autant en faire un composant.

En dérivant de TComponent tu peux sérialiser dans un flux,comme le montre le copier/coller de l'aide Delphi proposé par shaiLeTroll.

Si tu es intéressé par la technique de sérialisation d'objets dans un flux je pourrais te fournir un exemple.

A ta place j'opterai pour une hierarchie de composants représentant chaque personnage en utilisant l'héritage pour spécialiser tes persos et la compositions pour leur adjoindre d'autres classes représentants des compétences ( genre TCompetences <- TSortMagique etc ).

petite précision sur les packet record

Modification: mes explications étaient quelque peu bancales, voir celles de ShaiTheTroll.

voila.
@+

**ShaiLeTroll** · 04/04/2007, 19h46

Fabrice ROUXEL, Test avant de te prononcer sur des mécanismes que tu ne connais pas ! En plus de ne pas connaître tu as montré un méconnaissance totale de la mémoire et de la logique informatique en général, tu as écrit une énormité, comment avec des champ de longueur variable le programme pourrait s'y retrouver, il lui faudrait pour chaque champ la longueur en préfixe comme les shortstring, donc les données seraient accompagnées de méta donnée, donc le résultat de la compression serait rarement plus petit !

le record en delphi est aligné !!!
donc avec mon premier exemple, avec l'alignement sur 4 (Projet | Options | Onglet Compilateur - Champs d'enregistrements alignés), voir aussi $A, voilà ce que ça donne en mémoire ... tu peux aussi regarder les autres ...

normalement, en C++ (Windows), l'alignement est de 8 mais comme Delphi par défaut c'est 8 pour les Inteldonc dans l'unité Windows on trouve {$ALIGN ON} qui permet d'aligner à 8 quoi qu'il arrive pour le reste du projet et quelques record sont en packed parce que le .h devait l'indiqué, ... je ne connais pas le c++ pour savoir cela

Code :

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

1
2
3
4
5
6
7
8
 
W1 B1 spare W2 spare I1 C1 W3
2  1  1     2  2     4  4  2
 
en packed
 
W1 B1 W2 I1 C1 W3
2  1  2  4  4  2

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
type
  TTestRecBad = packed record
    W1: Word;
    B1: Byte;
    W2: Word;
    I1: Integer;
    C1: Cardinal;
    W3: Word;
    B2: Byte;
end;
 
type
  TTestRecGood = record
    B1 : Byte;
    B2 : Byte;
    W1 : Word;
    C1 : Cardinal;
    I1 : Integer;
    A1 : Array[1..12] of Char;
    A2 : Array[1..12] of Char;
end;
 
type
  TTestRecVariableBad = packed record
    case integer of
      0: (
         Low  :Byte;
         Med  :Word;
         High :Byte;
      );
      1: (
         Long: Integer;
      );
end;
 
type
  TTestRecVariableGood = record
    case integer of
      0: (
         Low  :Byte;
         Med1 :Byte;
         Med2 :Byte;
         High :Byte;
      );
      1: (
         Long: Integer;
      );
end;

**MelkInarian** · 04/04/2007, 19h51

Envoyé par Fabrice ROUXEL 1

Salut MelkInarian
Si tu presentes au joueur une fiche de competences du PNJ qu'il doit renseigner à la main, de toutes facon je ne vois pas sur quels criteres tu boucleras.
Les affectations il faudra bien les écrire à un moment.Tu peux chercher dans la vcl il n'y a aucune fonction qui t'y aidera.

Sinon, il y a d'autres facon de procéder.
Utiliser les fichiers à accés séquentiels (non direct) ou bien les fichiers binaires sachant pour ces derniers que tu devras coder les procedures de lecture/Ecritures.

Maintenant, si le PNJ evolue dans un environnement 2D/3D/3D isometrique et que tu dois le manipuler etc, autant en faire un composant.

En dérivant de TComponent tu peux sérialiser dans un flux,comme le montre le copier/coller de l'aide Delphi proposé par shaiLeTroll.

Si tu es intéressé par la technique de sérialisation d'objets dans un flux je pourrais te fournir un exemple.

A ta place j'opterai pour une hierarchie de composants représentant chaque personnage en utilisant l'héritage pour spécialiser tes persos et la compositions pour leur adjoindre d'autres classes représentants des compétences ( genre TCompetences <- TSortMagique etc ).

petite précision sur les packet record

Dans un record la taille réservée aux élements est définie par le type de ces élements.on a 1 double c'est 8 octets, un single c'est 4 octets. C'est fixe, c'est comme cela et donc l'acces est rapide on ne calcule rien on se fie aux tailles des types de données pour accéder aux élements.

Dans le cas des Packed record, un element peut etre stoque dans un espace plus petit que sa taille ne l'indique.Les données sont compressées et l'acces n'est pas optimal.
Il suffit de faire un IntToStr(SizeOf(recordnoncompresse)) et un IntToStr(SizeOf(recordcompresse)) pour s'en convaincre.

Et puis tu imagines bien dans le cas des packed record que si le type reel de l'element ne correspond plus a la taille réduite qui lui est allouée dans le record, la compatiblité de type avec d'autre langage comme le C ou C++ n'est plus assurée.

voila.
@+

Merci pour toutes ces précisions.
Tu as raison au niveau des affectations à faire lors de la création / modification il y a nécessairement une saisie.
Ma réflexion portait uniquement sur 2 points:
- la partie sauvegarde, une fois que la structure a été complétée (manuellement par saisie), pour archiver sur disque sans réécrire la liste complète et
- la partie chargement pour modifier un PJ/PNJ qui change de niveau.
Je pensais pouvoir raccourcir le code.

Pour ce qui est des composants, je n'ai pas le niveau.
J'ai appris Delphi tout seul dans mon coin, je suis un amateur. Il y a plein de notions qui me dépassent. J'ai bien téléchargé le tutoriel pour créer ses propres composants. J'ai suivi pas à pas et créé un petit 'truc' qui marchait aussi sous excel mais il me manque les bases et le temps pour les acquérir. Mais tu me proposes de me donner un exemple et je suis d'accord, c'est en décortiquant les exemples documentés que j'avance à mon rythme.

Pour ce qui est des packed record, je n'y ai jamais touché "s'il t'en manque c'est pas moi qui les ai pris" Plaisanterie mis à part, le type record me va bien et associé à des fichiers .ini je pense m’en sortir

Encore merci pour tout.
Melk

**Fabrice ROUXEL 1** · 04/04/2007, 20h03

ok

N'hésites pas à reposter si tu as des problemes d'implémentation.

Bon développement.

**MelkInarian** · 04/04/2007, 20h06

Envoyé par ShaiLeTroll

Sinon, encore plus simple !
Tu déclare un TComponent, tu mets tes propriétés en published (avec valeur par default par prudence) et utilise ces fonctions issus de l'aide de Delphi !
Et cela permet de gérer en plus facile l'évolution des objets (l'ajout de propriétés, la suppression étant à éviter au possible)
Ces fonctions manipulent des chaines que tu peux lire et écrire dans un fichier, et c'est ni plus ni moins des DFM !!!
voilà Standard Delphi !
Ah, oui faut penser à faire un RegisterClasses() des classes TPNJ et autres ...
Sinon, la solution du Packed Record, et du File of Record, est tout à fait utilisable, il faut juste gérer un entête pour la version et conserver dans une unité l'historique des versions des structures pour la migration, juste un peu rigueur c'est tout !

ah oui Packed <> compressé, c'est juste "non aligné en mémoire" cela n'a rien à voir et c'est ainsi compatible avec les structures C !

J'ai répondu à Fabrice ROUXEL 1 sans même avoir pris le temps de lire tous les posts. Je n'avais pas vu le tien. Mais comme je le disais dans le message précédent, les composants ben c'est pas ma tasse de thé.
Ton code est concis (c'est ce que je cherchais) mais au delà de mon entendement.
Je dois me mettre en quête de tutoriels sur les Txxxstream.
Je pourrai tout de même clamer partout avoir eu à faire à un Troll avec 24 en Intelligence (c'est pas banal dans mon jeu de rôle).
Merci ShaiLeTroll.

**Fabrice ROUXEL 1** · 04/04/2007, 20h14

Bonsoir ShaiLeTroll

As tu une explication au bout de code suivant stp?
Il y a juste un copier/coller à faire dans le onCreate de la fiche.

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
 
****
 
procedure TForm1.FormCreate(Sender: TObject);
type
 
  TSimpleRecord = Record
    name1   : string[4];
    floater : single;
    name2   : char;
    int     : Integer;
  end;
 
 
  TPackedRecord = Packed Record
    name1   : string[4];
    floater : single;
    name2   : char;
    int     : Integer;
  end;
 
var
  simpleRec : TSimpleRecord;
  packedRec  : TPackedRecord;
 
begin
  ShowMessage('Taille du record simple = '+IntToStr(SizeOf(SimpleRec)));
  ShowMessage('taille du packet record = '+IntToStr(SizeOf(packedRec)));
end;

**ShaiLeTroll** · 04/04/2007, 20h19

^_^, Attention Troll Guerrier-Mage, avec Armure Complète de Magicien +5, Fléau à Quatre Têtes (Feu, Glace, Eclair, Acide), ... lol, j'ai joué à Baldur et NWN, et très mauvais vrai rôliste en Pendagron ...

Sinon, tu devrais tenter la sérialisation, c'est quelque chose de très répandu, avec un Fichier Ini, tu peux facilement en faire aussi car tu as le nom et la valeur, et la rubrique pour indiquer la classe, ... sinon, perso, le record associé à un file of record ou file of byte (blockwrite, blockread), c'est très efficace, c'est justement l'évolution des fichiers qui peut poser problème ... mais l'avantage c'est que c'est rapide en run et court en design

si non pour le code, je n'ai même pas besoin de le coller, je connais mes règles d'alignement et les tailles des champs

Code :

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

1
2
3
4
5
6
  TSimpleRecord = Record
    name1   : string[4];
    floater : single;
    name2   : char;
    int     : Integer;
  end;

4+1 (shortstring)
3 spare
4
1
3 spare
4
=
4+1+3+4+1+3+4=20

Code :

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

1
2
3
4
5
6
 TPackedRecord = Packed Record
    name1   : string[4];
    floater : single;
    name2   : char;
    int     : Integer;
  end;

4+1 (shortstring)
4
1
4
=
4+1+3+4+1+3+4=14

**philnext** · 04/04/2007, 20h40

Bon..j'arrive après la bataille mais pourquoi on ne passerait pas simplement par des *.ini ?
C'est simple, évolutif, (certe pas très compact ni protégé) et simple à comprendre et implémenter.

**ShaiLeTroll** · 04/04/2007, 20h43

Tu arrives après et tu ne lit pas non plus !

**MelkInarian** · 04/04/2007, 20h48

[QUOTE=ShaiLeTroll Sinon, tu devrais tenter la sérialisation, c'est quelque chose de très répandu, avec un Fichier Ini, tu peux facilement en faire aussi car tu as le nom et la valeur, et la rubrique pour indiquer la classe, [/QUOTE]
Quand je saisis "sérialisation" dans le moteur de recherche j'ai du Java, PHP et autre .NET mais je ne vois pas de Delphi (je me suis arrété au 5 premières pages). Aurais-tu un lien vers un tuto pour que je vois de quoi ça parle?
Merci.

**philnext** · 04/04/2007, 20h51

Envoyé par ShaiLeTroll

Tu arrives après et tu ne lit pas non plus !

Gulp !
En fait j'avais l'impression que ça avait été abandonné pour des solutions plus compliquées...

**ShaiLeTroll** · 04/04/2007, 20h52

Je n'aurais pas de tuto, mais il faut déjà te familiariser avec les TComponent (property et published) ... après on parlera de gestion de flux et du RTTI ... ayant fait une couche de persistance, j'ai écrit des fonctions qui convertissent des stringlist (je peux l'adapter au ini) en DFM pour être avalé par les deux fonctions de l'aide delphi ... mais le mieux reste de gérer var l'unité TypInfo ... mais il faut être à l'aise avec les variants dans ce cas ...

@Phil
Non, on soumet un grand nombre d'idée, c'est juste qu'il dommage d'écrire temps de ligne alors que le RTTI en conservant le fichier permettrait de faire ça dans une boucle ...

[D5] Charger rapidement un type record

Delphi

Discussions similaires

Partager

Partager