Création d'une nouvelle liste de chaînes

De RAD Studio
Aller à : navigation, rechercher

Remonter à Utilisation des listes de chaînes

Habituellement, une liste de chaînes fait partie intégrante d'un composant. Néanmoins, il est parfois commode de créer des listes de chaînes autonomes qui n’ont pas de composant associé (par exemple, pour stocker les chaînes d’une table de référence). La manière de créer et de gérer une liste de chaînes varie selon que la liste est une liste à court terme (construite, utilisée et détruite dans une même routine) ou une liste à long terme (disponible jusqu'à l'arrêt de l’application). Quel que soit le type de liste de chaînes créé, n’oubliez pas que c'est à vous de libérer la liste quand vous n'en avez plus besoin.

Listes de chaînes à court terme

Si vous utilisez une liste de chaînes uniquement pour la durée d’une seule routine, vous pouvez la créer, l’utiliser et la détruire au même emplacement. C’est la méthode la plus fiable pour utiliser des objets listes de chaînes.

Delphi :
Comme l'objet liste de chaînes alloue la mémoire pour lui-même et pour ses chaînes, il est important de protéger l'allocation en utilisant un bloc try... finally afin de garantir que l'objet libère sa mémoire même si une exception a lieu.

Pour créer une liste de chaînes à court terme :

  1. Construisez l'objet liste de chaînes.
  2. Dans la partie try d'un bloc try... finally, utilisez la liste de chaînes.
  3. Dans la partie finally, libérez l'objet liste de chaînes.

C++ :
Comme l’objet liste de chaînes alloue la mémoire pour lui-même et pour ses chaînes, il est important de protéger l’allocation en utilisant un bloc try...__finally afin de garantir que l’objet libère sa mémoire même si une exception a lieu.

Pour créer une liste de chaînes à court terme :

  1. Construisez l'objet liste de chaînes.
  2. Dans la partie try d'un bloc try...__finally, utilisez la liste de chaînes.
  3. Dans la partie __finally, libérez l'objet liste de chaînes.

Le gestionnaire d'événement suivant répond au choix d’un bouton en construisant un objet liste de chaînes, en l'utilisant puis en le détruisant

:
 procedure TForm1.Button1Click(Sender: TObject);
  var  TempList: TStrings;{ declare the list }
  begin
    TempList := TStringList.Create;{ construct the list object }
    try    { use the string list }
    finally    TempList.Free;{ destroy the list object }
    end;
  end;
 void __fastcall TForm1::ButtonClick1(TObject *Sender)
 {
 TStringList *TempList = new TStringList; // declare the list
 try{
 //use the string list
 }
 __finally{
 delete TempList; // destroy the list object
 }
 }

Listes de chaînes à long terme

Si la liste de chaînes doit être disponible tout au long de l'exécution de votre application, vous devez construire la liste au démarrage de l'application et la détruire avant la fermeture de l'application.

Pour créer une liste de chaînes à long terme :

  1. Dans le fichier unité de la fiche principale de votre application, ajoutez un champ de type TStrings à la déclaration de la fiche.
  2. Créez un gestionnaire d'événement pour l'événement OnCreate de la fiche principale qui s'exécute avant que la fiche n'apparaisse. Ce gestionnaire d'événement doit créer une liste de chaînes et l'affecter au champ déclaré dans la première étape.
  3. Ecrivez un gestionnaire d'événement qui libère la liste de chaînes dans l'événement OnClose de la fiche.

L’exemple suivant utilise une liste de chaînes à long terme pour stocker les clics de la souris dans la fiche principale, puis enregistre la liste dans un fichier avant l’arrêt de l’application

:
 unit Unit1;
  interface
  uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs;
  type  TForm1 = class(TForm)
      procedure FormCreate(Sender: TObject);
      procedure FormDestroy(Sender: TObject);
      procedure FormMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
    private
      { Private declarations }
    public
      { Public declarations }
      ClickList: TStrings;{ declare the field }
    end;
  var  Form1: TForm1;
  implementation
  {$R *.DFM}
  procedure TForm1.FormCreate(Sender: TObject);
  begin
  		ClickList := TStringList.Create;{ construct the list }
  end;
  
  procedure TForm1.FormDestroy(Sender: TObject);
  begin
  	ClickList.SaveToFile(ChangeFileExt(Application.ExeName, '.log'));{ save the list }
   ClickList.Free;{ destroy the list object }
  end;
  
  procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton;  Shift: TShiftState; X, Y: Integer);
  begin
  	ClickList.Add(Format('Click at (%d, %d)', [X, Y]));{ add a string to the list }
  end;
  
  end.
 //---------------------------------------------------------------------------
 #include <vcl.h>
 #pragma hdrstop
 #include "Unit1.h"
 //---------------------------------------------------------------------------
 #pragma package(smart_init)
 #pragma resource "*.dfm"
 TForm1 *Form1;
 //---------------------------------------------------------------------------
 __fastcall TForm1::TForm1(TComponent* Owner)
 : TForm(Owner)
 {
 ClickList = new TStringList;
 }
 //---------------------------------------------------------------------------
 void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
 {
 ClickList->SaveToFile(ChangeFileExt(Application->ExeName, ".LOG"));//Save the list
 delete ClickList;
 }
 //---------------------------------------------------------------------------
 void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button,
 TShiftState Shift, int X, int Y)
 {
 TVarRec v[] = {X,Y};
 ClickList->Add(Format("Click at (%d, %d)",v,ARRAYSIZE(v) - 1));//add a string to the list
 }

Remarque : Même si vous pouvez utiliser des événements tels que OnCreate et OnDestroy pour allouer et libérer des classes, l'utilisation du constructeur et du destructeur pour une classe est généralement une pratique de codage plus sûre.

Voir aussi