Eine neue Stringliste erstellen

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Mit Stringlisten arbeiten

Eine Stringliste ist normalerweise Teil einer Komponente. Es gibt jedoch Situationen, in denen unabhängige Stringlisten erstellt werden müssen, beispielsweise um Strings für eine Nachschlagetabelle zu speichern. Wie Sie eine Stringliste erstellen und verwalten, ist davon abhängig, ob es sich um eine kurzlebige Stringliste handelt (die innerhalb einer einzigen Routine erstellt, verwendet und freigegeben wird) oder um eine langlebige (die zur Verfügung steht, bis die Anwendung geschlossen wird). Unabhängig davon, welchen Typ Sie erstellen, müssen Sie die Stringliste selbst wieder freigeben, wenn Sie sie nicht mehr benötigen.

Kurzlebige Stringlisten

Wenn Sie Stringlisten nur innerhalb einer einzigen Routine benötigen, können Sie sie innerhalb dieser Routine anlegen, verwenden und freigeben. Dies ist die sicherste Art und Weise, mit Stringlisten zu arbeiten.

Delphi:
Da das Stringlisten-Objekt für sich und seine Strings Speicher reserviert, sollten Sie mit einem try...'' finally-Block sicherstellen, dass dieser Speicher auch dann freigegeben wird, wenn eine Exception ausgelöst wird.

So erstellen Sie kurzlebige Stringlisten:

  1. Legen Sie das Stringlisten-Objekt an.
  2. Verwenden Sie die Stringliste im try-Abschnitt eines try... finally-Blocks.
  3. Geben Sie im finally-Abschnitt das Stringlisten-Objekt frei.

C++:
Da das Stringlisten-Objekt für sich und seine Strings Speicher reserviert, sollten Sie mit einem try...__finally-Block sicherstellen, dass dieser Speicher auch dann freigegeben wird, wenn eine Exception ausgelöst wird.

So erstellen Sie kurzlebige Stringlisten:

  1. Legen Sie das Stringlisten-Objekt an.
  2. Verwenden Sie die Stringliste im try-Abschnitt eines try...__finally-Blocks.
  3. Geben Sie im __finally-Abschnitt das Stringlisten-Objekt frei.

Die folgende Ereignisbehandlungsroutine reagiert auf einen Schaltflächenklick, indem sie eine Stringliste erzeugt, sie verwendet und dann wieder freigibt:

Delphi:
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;
C++:
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
 }
 }

Langlebige Stringlisten

Sofern eine Stringliste während der gesamten Ausführung Ihrer Anwendung zur Verfügung stehen muss, legen Sie die Liste beim Starten an und geben sie vor dem Beenden der Anwendung frei.

So erstellen Sie langlebige Stringlisten:

  1. Fügen Sie in der Unit-Datei für das Hauptformular Ihrer Anwendung ein Feld des Typs TStrings in die Formulardeklaration ein.
  2. Schreiben Sie eine Ereignisbehandlungsroutine für das Ereignis OnCreate des Hauptformulars, die ausgeführt werden soll, bevor das Formular angezeigt wird. Sie sollte eine Stringliste erzeugen und sie dem Feld zuweisen, das Sie im ersten Schritt deklariert haben.
  3. Schreiben Sie eine Ereignisbehandlungsroutine für das Ereignis OnClose des Formulars, die die Stringliste freigibt.

Das folgende Beispiel verwendet eine langlebige Stringliste, um die Mausklicks des Benutzers im Hauptformular aufzuzeichnen, und speichert die Liste in einer Datei, bevor die Anwendung beendet wird:

Delphi:
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.
C++:
//---------------------------------------------------------------------------
 #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
 }

Hinweis: Obwohl Sie Klassen mit Ereignissen, wie z.B. OnCreate und OnDestroy zuweisen und freigeben können, ist es im Allgemeinen sicherer dazu den Konstruktor bzw. Destruktor zu verwenden.

Siehe auch