Objet ou Packed record ? [Résolu]

Toya78 49 Messages postés vendredi 1 septembre 2006Date d'inscription 23 août 2008 Dernière intervention - 4 janv. 2008 à 23:46 - Dernière réponse : /dev/null 13 Messages postés jeudi 2 octobre 2003Date d'inscription 14 janvier 2008 Dernière intervention
- 14 janv. 2008 à 23:06
Bonjour à tous,



Travaillant sur un gros projet perso, je me suis soudain rendu compte que j'avais un choix à faire.



Voici la situation : mon programme doit lire de nombreuses informations dans un très gros fichier (informations structurées en article). J'ai 2 solutions :



Solution 1 :
type
   TInfo = packed record
      entier : Integer;
      mot : Word;
      mot2 : Word;
   end;



   TGroupe = class
      private
         _infos : array of TInfos;
      public
         //...
   end;



Dans cet exemple, ce qui est intéressant c'est le packed record car il permet de lire plus rapidement le fichier avec un simple mon_file_stream.Read(mon_info, SizeOf(mon_info)). De plus, pas besoin de se préoccuper de la destruction des TInfo.




 



Toutefois, je suis tenté de passer ce packed record en classe (qui n'aurait que des attributs privés et des propriétés pour y accéder), afin de pouvoir les gérer en tant qu'objets et ainsi utiliser un TObjectList plutôt qu'un tableau dynamique.



Solution 2 :
type
   TInfo = class
      private
         _entier : Integer;
         _mot : Word;
         _mot2 : Word;
      public
         //...
      property
         //accès aux attribus privés
   end;



   TGroupe = class
      private
         _infos : TObjectList;   //stocke les TInfo
      public
         ...
   end;



Ici, l'avantage c'est que la gestion des TInfo sera plus agréable grâce au TObjectList.



Pour résumer :
soit : des packed record stockés dans un tableau (plus rapide pour la lecture du fichier et évite de gérer les destructions d'objets)
soit : des objets stockés dans un TObjectList (plus agréable pour gérer les objets)



J'hésite vraiment entre les deux... à moins qu'il existe une classe TPackedRecordList lol



Quel est votre avis ?



Merci d'avance
Afficher la suite 

Votre réponse

14 réponses

Meilleure réponse
WhiteHippo 1270 Messages postés samedi 14 août 2004Date d'inscription 5 avril 2012 Dernière intervention - 5 janv. 2008 à 11:41
3
Merci
Bonjour

Allez de quoi te donner un peu plus de matière pour ta reflexion. Tu gardes la première solution, mais tu crées en plus une classe de manipulation de tes données :

type
  PInfo = ^TInfo
  TInfo = packed record
     entier : Integer;
     mot : Word;
     mot2 : Word;
   end;



 TClassInfo = class
 private
   FInfo : PInfo ; 
 public
   constructor Create( AInfo : PInfo ) ;
   property ...
 end;


Tu utilises alors cette classe juste pour faciliter l'accès à tes données lorsque tu as besoin de les manipuler.

var
  UneInfo : TClassInfo ;
begin
  UneInfo := TClassInfo .Create( @_infos[1] ) ;
  try
    // Manipulation des données
    UneInfo.entier := UneInfo.entier + 10 ;
  finally
    UneInfo.Free;
  end ;
end ;

P.S. Ne connaissant ni ton niveau, ni ton avancement dans ton projet, je ne peux que te proposer une solution, parmi beaucoup d'autres, en fonction des éléments que tu as fourni.

Cordialement.
<hr />"L'imagination est plus importante que le savoir." Albert Einstein

Merci WhiteHippo 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 90 internautes ce mois-ci

Commenter la réponse de WhiteHippo
Meilleure réponse
florenth 1105 Messages postés dimanche 1 août 2004Date d'inscription 17 août 2008 Dernière intervention - 5 janv. 2008 à 13:57
3
Merci
J'aime bien ta solution WhiteHippo, entre les deux autres en fait (mi-classe, mi-record).
Sinon, au sujet de la taille des données à charger: si ton fichier fait 130Mo, cela signifie que le charger en entier te prendra 130Mo minimum en mémoire (en réalité, plus que cela). Je te conseille alors de passer par un TObjectList qui à l'avantage d'être une liste de pointeurs, ce qui fait que les 130Mo ne devront pas forcément être contigus comme ce serait le cas pour un array of record.

Par contre, tu risques de prendre quelques kilo-octets de plus en mémoire. Mais sur 130Mo, c'est négligeable.

Pour ce qui est de la vitesse de lecture, saches que la classe TFileStream est très optimisée (en fait, pas vraiment, c'est Windows et ses fonctions qui le sont) et qu'une partie du fichier est mis en cache mémoire. Ce qui fait qu'au final, il n'y a pas un accès au disque dur par Stream.Read() mais à chaque fois que tu dépasses ce buffer interne.

Saches d'ailleurs que j'ai déjà manipulé des fichiers de plusieurs gigas (pas en mémoire, c'était pour de la recherche d'informations) et que je n'ai pas eu de problèmes. Du moment que le fichier fait moins de 4Go, c'est tout bon, après, ça pose quelques problèmes (le type Integer pas assez grand, ...) mais on n'est pas encore là.

Voila, bon week-end,
Flo

Ressources Delphi, sources, tutoriaux, actu, ...: www.mx-dev.nethttp://te%3C/body

Merci florenth 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 90 internautes ce mois-ci

Commenter la réponse de florenth
florenth 1105 Messages postés dimanche 1 août 2004Date d'inscription 17 août 2008 Dernière intervention - 5 janv. 2008 à 11:29
0
Merci
Salut !

Tout dépend de ce que tu comptes faire avec ta liste: si c'est juste ajout, lecture, suppression totale, tu peux garder des record, c'est très bien comme cela.
Par contre, si tu as besoin de plus de souplesse (ré ordonnancement des record) ou bien d'avoir des getter/setters spéciaux ou encore si ta classe TGroupe se préoccupe un peu trop de ce que font des TInfo (ce qui ne devrait jamais être le cas) alors il est peut être judicieux de passer à une classe.

Si c'est le chargement/sauvegarde dans un flux qui te pose problème, saches que ce n'est vraiment pas plus compliqué avec des classes. Il faut juste penser à créer deux méthodes dans TInfo (LoadFromStream() et SaveToStream()) qui s'occuperont du tout.

Voila, j'ai essayé d'être concis dans ma réponse.

A+
Flo

Ressources Delphi, sources, tutoriaux, actu, ...: www.mx-dev.nethttp://te%3C/body
Commenter la réponse de florenth
Toya78 49 Messages postés vendredi 1 septembre 2006Date d'inscription 23 août 2008 Dernière intervention - 5 janv. 2008 à 11:41
0
Merci
Merci Florenth de t'intéresser au sujet.
En effet ce n'est pas plus compliqué de gérer ces chargements/enregistrements dans les flux. Mon appli est déjà en "objets" d'ailleurs :). Le seul soucis qui me préoccupait était les performances de lecture (le traitement est assez lourd : il y a beaucoup d'articles et le fichier pèse 130Mo :p). En effet, je pensais que c'était plus rapide de faire :

mon_file_stream.Read(mon_packed_record, SizeOf(mon_packed_record));       //Affecte en une seule lecture les 3 attributs du packed record

plutôt que :

mon_file_stream.Read(mon_objet.attribut1, 1);
mon_file_stream.Read(mon_objet.attribut2, 2);
mon_file_stream.Read(mon_objet.attribut3, 2);        //3 lectures nécessaires pour affecter les 3 attributs

Toutefois je viens de retester les temps d'exécution, et il se trouve que les 2 se valent (je précise que dans mon projet, il y a beaucoup plus d'attributs). Pourtant j'ai toujours lu et entendu dire que les lectures prenaient beaucoup de temps... Je m'y perds...
Commenter la réponse de Toya78
Toya78 49 Messages postés vendredi 1 septembre 2006Date d'inscription 23 août 2008 Dernière intervention - 5 janv. 2008 à 22:18
0
Merci
Alors c'est génial ! Merci Florenth pour tes précieux conseils ;)
En effet la solution de WhiteHippo (que je remercie au passage) a l'air intéressante je vais me pencher là-dessus.

Merci à vous deux pour votre aide.

En vous souhaitant un bon week-end :)
Commenter la réponse de Toya78
/dev/null 13 Messages postés jeudi 2 octobre 2003Date d'inscription 14 janvier 2008 Dernière intervention - 7 janv. 2008 à 02:53
0
Merci
Je t'aurais répondu comme WhiteHippo, mais je t'aurais en plus recomandé d'utilisé la projection de fihier en mémoire. Si tu trouve que les TStream sont pratique a employé va là -> http://www.delphifr.com/codes/MAPPING-FICHIER-TSTREAM_39879.aspx 

De toutes les chose que j'ai perdues...
Celle qui me manque le plus...
C'est mon esprit.
Commenter la réponse de /dev/null
f0xi 4304 Messages postés samedi 16 octobre 2004Date d'inscription 9 mars 2018 Dernière intervention - 7 janv. 2008 à 16:43
0
Merci
type
  TFileHeader = record
    ReservedA : int64;  { options a ajouter }
    ReservedB : int64;  { options a ajouter }
    ReservedC : int64;  { options a ajouter }
    ItemCount : integer;
  end;
  pFileHeader = ^TFileHeader;

const
  FileHeaderSize = SizeOf(TFileHeader);

type
  TFileItem = record
    value1 : integer;
    value2 : word;
    value3 : byte;
  end;
  pFileItem = ^TFileItem;

const
  FileItemSize = SizeOf(TFileItem);

type
  TMyFile = class(TList)
  private
    function GetItem(index: integer): TFileItem;
    procedure PutItem(index: integer; value: TFileItem);
  protected
    procedure Notify(Ptr: Pointer; Action: TListNotification); override;
  public
    function Add(Item: TFileItem): Integer;
    procedure Insert(Index: Integer; Item: TFileItem);
    function IndexOf(Item: TFileItem): Integer;
    property Items[Index: Integer]: TFileItem read GetItem write PutItem; default;
    function First: TFileItem;
    function Last: TFileItem;
    procedure Clear; override;
    procedure SaveToFile(const FileName: string);
    procedure LoadFromFile(const FileName: string);
    procedure SaveToStream(Stream: TStream);
    procedure LoadFromStream(Stream: TStream);
  end;

function FileItem(const V1: integer; const V2: Word; const V3: Byte): TFileItem;
begin
  result.value1 := V1;
  result.value2 := V2;
  result.value3 := V3;
end;

function FileItemStr(const Item: TFileItem): string;
begin
  result := format('< %d / %d / %d >',[Item.value1, Item.value2, Item.value3]);
end;

{ TMyFile }

procedure TMyFile.Notify(Ptr: Pointer; Action: TListNotification);
begin
  if (ptr <> nil) and (Action = lnDeleted) then
  begin
    Dispose(ptr);
    ptr := nil;
  end;
end;

function TMyFile.Add(Item: TFileItem): Integer;
var ptr : pFileItem;
begin
  new(ptr);
  ptr^ := Item;
  result := inherited Add(ptr);
end;

procedure TMyFile.Clear;
begin
  while Count > 0 do
    Delete(Count-1);
  inherited Clear;
end;

function TMyFile.First: TFileItem;
begin
  result := pFileItem(inherited First)^;
end;

function TMyFile.GetItem(index: integer): TFileItem;
begin
  result := pFileItem(inherited Get(index))^;
end;

function TMyFile.IndexOf(Item: TFileItem): Integer;
var N : integer;
    ptrA, ptrB : pFileItem;
begin
  ptrA := @Item;
  for N := 0 to Count-1 do
  begin
    ptrB := pFileItem(inherited get(N));
    if CompareMem(ptrA, ptrB, FileItemSize) then
    begin
      result := N;
      break;
    end;
  end;
end;

procedure TMyFile.Insert(Index: Integer; Item: TFileItem);
var ptr: pFileItem;
begin
  new(ptr);
  ptr^ := Item;
  inherited Insert(index, ptr);
end;

function TMyFile.Last: TFileItem;
begin
  result := pFileItem(inherited Last)^;
end;

procedure TMyFile.PutItem(index: integer; value: TFileItem);
begin
  pFileItem(inherited get(index))^ := value;
end;

procedure TMyFile.LoadFromFile(const FileName: string);
var stream: TFileStream;
begin
  Stream := TFileStream.Create(FileName, fmOpenRead);
  try
    LoadFromStream(Stream);
  finally
    Stream.Free;
  end;
end;

procedure TMyFile.LoadFromStream(Stream: TStream);
var
  FileHeader : TFileHeader;
  FileItem   : TFileItem;
  N          : integer;
begin
  Stream.Read(FileHeader, FileHeaderSize);
  for N := 0 to FileHeader.ItemCount-1 do
  begin
    Stream.Read(FileItem, FileItemSize);
    Add(FileItem);
  end;
end;

procedure TMyFile.SaveToFile(const FileName: string);
var Stream: TFileStream;
begin
  Stream := TFileStream.Create(FileName, fmCreate);
  try
    SaveToStream(Stream);
  finally
    Stream.Free;
  end;
end;

procedure TMyFile.SaveToStream(Stream: TStream);
var
  FileHeader : TFileHeader;
  FileItem   : TFileItem;
  N          : integer;
begin
  FileHeader.ItemCount := Count;
  Stream.Write(FileHeader, FileHeaderSize);

  for N := 0 to Count-1 do
  begin
    FileItem := Items[N];
    Stream.Write(FileItem, FileItemSize);
  end;
end;



performances :

sauvegarde de 100 000 entrées : 524 ms
chargement de 100 000 entrées : 120 ms

<hr size="2" width="100%" />
http://deefaze.gnomz.com
Commenter la réponse de f0xi
Toya78 49 Messages postés vendredi 1 septembre 2006Date d'inscription 23 août 2008 Dernière intervention - 7 janv. 2008 à 18:36
0
Merci
Merci /dev/null de ta source le mapping est un sujet que je ne connais pas mais je vais m'y intéresser !

Merci à toi f0xi également (j'ose espérer que tu avais ce morceau de code déjà tout fait quelque part :o) ). Je vais examiner tout ça calmement ça a l'air intéressant ;)
Commenter la réponse de Toya78
florenth 1105 Messages postés dimanche 1 août 2004Date d'inscription 17 août 2008 Dernière intervention - 7 janv. 2008 à 20:36
0
Merci
Non non, à mon avis, il l'a écrit en live dans la TextBox !
C'est un brave ce f0xi !

Sinon, pour lancer le débat, f0xi, ne vaudrait-il pas mieux composer plutôt que d'hériter TList ?
Si tu n'as pas besoin de toutes les fonctions (ce qui est le cas à 90%), alors ça fait moins de travail.
Certes, ici c'est TList donc on n'est pas obligé de tout surcharger (pas comme avec TObjectList sinon gare aux bugs !) alors ça m'intéresserai d'avoir ton point de vue la dessus.
Il me semble que Delphiprog parlait lui aussi de composition...

NB: pas composition, j'entends ceci:

type
  TMyFile = class(TObject)
  private
    FList: TList;
    // Accesseurs des propriétés
  public
    [...]
    procedure Add(...)
    [...]
  end;

Ressources Delphi, sources, tutoriaux, actu, ...: www.mx-dev.nethttp://te%3C/body
Commenter la réponse de florenth
f0xi 4304 Messages postés samedi 16 octobre 2004Date d'inscription 9 mars 2018 Dernière intervention - 10 janv. 2008 à 19:46
0
Merci
oui florenth on peu faire les deux.
heritage ou composition ... tout depend de ce qu'on veux en faire aprés.
mais le principe reste le meme, puisque dans le cas de l'heritage on travailera avec les inherited a gogo et qu'avec la compo on travaillera avec les methodes d'un objet fList (TList).

les deux methodes sont bonnes bien que la composition est plus "facile" et propre.

ici l'avantage de l'heritage est de pouvoir acceder directement a TList (Get, Put, Items, etc)

function GetItem(index: integer) : TFileItem;
begin
  result := pFileItem(inherited Get(index))^;
end;

la ou en composition on devrait faire :

function GetItem(index: integer) : TFileItem;
var ptr: pointer;
begin
  ptr := fList.Items[index];
  result := pFileItem(ptr)^;
end;

et surtout aussi, l'heritage permet d'acceder a la methode protected TList.Notify qui permet de regler les cas d'actions sur les items (add, delete, extract etc)

donc voila, pour ma part je prefere l'heritage puis la composition comme pour TStrings, TStringsList puis composition TListBox, TMemo, TComboBox etc.
ça reviens un peu commme quand on crée une collection :
CollectionItem > Collection > Composant/Manager

bon par contre, l'heritage specialise la nouvelle classe qui ne sera utilisable que pour cela, la ou la composition permet d'utiliser la TList comme bon nous semble (melange de type (risqué!)).
donc cela prouve bien que les deux solutions sont bonnes, cela depend surtout de l'utilisation qu'on vas en faire. juste que l'heritage demande une attention plus poussée pour eviter les bugs.

<hr size="2" width="100%" />
http://deefaze.gnomz.com
Commenter la réponse de f0xi
florenth 1105 Messages postés dimanche 1 août 2004Date d'inscription 17 août 2008 Dernière intervention - 10 janv. 2008 à 20:12
0
Merci
Merci de ton éclaircissement. En effet, si on veut consacrer la classe pour sa fonction de liste, alors autant hériter.
Mais faut faire gaffe en effet, la composition limite de ce côté les bugs.
Mais elle permet aussi d'éviter d'exposer certaines méthodes dérivées de TList qu'il vaut mieux dans certains cas laisser de côté (comme les cas où Add doit faire quelque chose de précis en plus de FList.Add, il faut empêcher l'utilisation de Insert).

PS: on peut aussi faire en une ligne :

function GetItem(index: integer) : TFileItem;
begin
  Result := pFileItem(fList[index])^;
end;

PS2 (pas la console): dommage qu'il n'y ai pas de moyen "simple" de faire des templates (à la c++)... pour les listes au moins ça serait utile.

Bonne prog'

Ressources Delphi, sources, tutoriaux, actu, ...: www.mx-dev.nethttp://te%3C/body
Commenter la réponse de florenth
salim07360 17 Messages postés mardi 6 décembre 2005Date d'inscription 22 janvier 2008 Dernière intervention - 13 janv. 2008 à 13:01
0
Merci
slt , j essayé  , mais ça marche pas tjrs ! j c pas pkoi , mais apparament c pas la bonne solution ! et en plus sous delphi5 , c pas kif kif , sous delphi7 , c plus rapide , et plus facile !
Commenter la réponse de salim07360
florenth 1105 Messages postés dimanche 1 août 2004Date d'inscription 17 août 2008 Dernière intervention - 14 janv. 2008 à 18:49
0
Merci
slt chsui un gros n??rd, j'pas ma vi d'vant un Pc mai j'arive pô à létaindr
Svp pleaaase aide me, ma factuR edf gonfle, G 1 interdi bankaiR à coz de sa !

Et sinon, aussi, c'est par ici : http://www.delphifr.com/reglement.aspx
Commenter la réponse de florenth
/dev/null 13 Messages postés jeudi 2 octobre 2003Date d'inscription 14 janvier 2008 Dernière intervention - 14 janv. 2008 à 23:06
0
Merci
lol 

De toutes les chose que j'ai perdues...
Celle qui me manque le plus...
C'est mon esprit.
Commenter la réponse de /dev/null

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.