[bonsai]

[C++ Tutorial für Borland C++ Builder] Mit TStringList-Objekten arbeiten:

Das TStringList-Objekt verwaltet eine Liste, die Strings enthält.


In diesem Tutorial wird folgendes Wissen vorausgesetzt: Mit String-Variablen arbeiten


Um eine bessere Übersicht zu schaffen, sind die folgenden Dinge farblich gekennzeichnet:

TStringList:..... TStringList *<Bezeichner> .= Name des TStringList-Objekts
Strings: .......... String <Bezeichner> ..........= Name der String-Variable
Stringliteral: ..."<Wert>" ...........................= Inhalt des Strings
Integer: .......... int <Bezeichner>
Kommentare: . // Kommentar



Methoden von TStringList:

Spoiler anzeigen

TStringList deklarieren:

TStringList *<Bezeichner> = new TStringList();

// Der Operator 'new' ermöglicht eine dynamische Speicherreservierung
// 'new' gibt einen Zeiger auf den zugewiesenen Speicher zurück
// Der Operator '*' wird verwendet um einen Zeiger zu erzeugen
// Die Methode 'TStringList()' erstellt ein neues TStringList-Objekt

/* Beispiel 1: */
TStringList *strList_Test = new TStringList();

// da man mit den Operatoren 'new' und '*' dynamischen Speicher 
// reserviert hat, muss man diesen immer manuell wieder freigeben!
// dafür verwendet man den Operator 'delete'
// 'delete' gibt einen Speicherbereich frei,
// der durch einen Aufruf von 'new' reserviert wurde

// WICHTIG: Der Operator 'delete' wird ohne 
// den Operator '*' (Zeiger) verwendet!

delete strList_Test;

TStringList: Strings hinzufügen, löschen, einfügen:

// Mit dem Operator '->' kann auf Methoden des TStringList-Objekts
// zugegriffen werden

// Strings hinzufügen - Rückgabewert (optional) ist die Zeilennummer,
// welche den angefügten String enthält
// wobei 0 die ersten Zeile bezeichnet; 1 die zweite, usw.
(int) <Bezeichner>->Add(<Bezeichner>);
(int) <Bezeichner>->Add("<Wert>");

// Strings löschen - Index gibt die Position des Strings an
// wobei 0 den ersten String bezeichnet; 1 den zweiten, usw.
// Sollte 'Delete' mit einem ungültigen Index-Wert aufgerufen werden
// wird eine Exception ausgegeben
<Bezeichner>->Delete(<Index>);

// alle Strings aus dem TStringList-Objekt löschen
<Bezeichner>->Clear();

// Strings einfügen - String an Position Index einfügen 
// wobei 0 die ersten Zeile bezeichnet; 1 die zweite, usw.
// Sollte 'Insert' mit einem ungültigen Index-Wert aufgerufen werden
// wird eine Exception ausgegeben
<Bezeichner>->Insert(<Index>, <Bezeichner>);
<Bezeichner>->Insert(<Index>, "<Wert>");

Beispiele - Strings hinzufügen, löschen:

/* Beispiel 1: */
String strTest1 = "Hallo", strTest2 = "Welt!";

// Beide Strings dem TStringList-Objekt hinzufügen - ohne Rückgabewert
strList_Test->Add(strTest1);
strList_Test->Add(strTest2);

// Beide Strings dem TStringList-Objekt hinzufügen - mit Rückgabewert
int Pos1 = strList_Test->Add(strTest1);
int Pos2 = strList_Test->Add(strTest2);

// Das TStringList-Objekt sieht dann wie folgt aus:
strList_Test:
  Hallo // Zeilen-Index 0 - Rückgabewert Pos1 = 0
  Welt! // Zeilen-Index 1 - Rückgabewert Pos2 = 1

// Die gerade hinzugefügten Strings löschen - manuell
// Reihenfolge beachten - sonst bekommt man eine Exception
strList_Test->Delete(1);
strList_Test->Delete(0);

// Die gerade hinzugefügten Strings löschen - mit dem Rückgabewert (Index)
// Reihenfolge beachten - sonst bekommt man eine Exception
strList_Test->Delete(Pos2);
strList_Test->Delete(Pos1);

// alternativ - 2x die erste Zeile löschen
strList_Test->Delete(0);
strList_Test->Delete(0);

// schnellste Variante
strList_Test->Clear();

Beispiele - Strings einfügen:

/* Beispiel 2: */

// Stringliterale "Das" und "Beispiel" hinzufügen
strList_test->Add("Das");
strList_test->Add("Beispiel");

// Das TStringList-Objekt sieht dann wie folgt aus:
strList_Test:
  Das       // Zeilen-Index 0
  Beispiel  // Zeilen-Index 1

// Stringliterale "ist" (Index 1) einfügen
strList_test->Insert(1, "ist");

// Das TStringList-Objekt sieht dann wie folgt aus:
strList_Test:
  Das       // Zeilen-Index 0
  ist       // Zeilen-Index 1
  Beispiel  // Zeilen-Index 2

// Stringliterale "ein" (Index 2) einfügen
strList_test->Insert(2, "ein");

// Das TStringList-Objekt sieht dann wie folgt aus:
strList_Test:
  Das       // Zeilen-Index 0
  ist       // Zeilen-Index 1
  ein       // Zeilen-Index 2
  Beispiel  // Zeilen-Index 3

TStringList: nach Strings suchen bzw. prüfen ob vorhanden:

int <Bezeichner> = <Bezeichner>->IndexOf(<Bezeichner>);
int <Bezeichner> = <Bezeichner>->IndexOf("<Wert>");

/* Beispiel 1: */

// prüfen ob "Hallo" im TStringList-Objekt vorhanden ist
// 'IndexOf' liefert den Zeilen-Index des Strings als Rückgabewert
// ist der String nicht im TStringList-Objekt enthalten, liefert
// 'IndexOf' den Wert '-1' als Rückgabewert
int iPos = strList_Test->IndexOf("Hallo");

// den Rückgabewert auswerten
if (iPos != -1)
{
  // Stringliteral "Hallo" hat den Index iPos
}
else
{
  // Stringliteral "Hallo" ist nicht im TStringList-Objekt enthalten
}

TStringList: Position von 2 Strings tauschen:

<Bezeichner>->Exchange(<Index1>, <Index2>);

/* Beispiel 1: */
strList_Test->Add("4");
strList_Test->Add("5");
strList_Test->Add("3");
strList_Test->Add("1");
strList_Test->Add("2");

// Das TStringList-Objekt vor dem Tausch:
strList_Test:
  4 // Zeilen-Index 0
  5 // Zeilen-Index 1
  3 // Zeilen-Index 2
  1 // Zeilen-Index 3
  2 // Zeilen-Index 4

// Index 0 ("4") und Index 3 ("1") tauschen
strList_Test->Exchange(0, 3);

// Index 1 ("5") und Index 4 ("2") tauschen
strList_Test->Exchange(1, 4);

// Das TStringList-Objekt sieht dann wie folgt aus:
strList_Test:
  1 // Zeilen-Index 0
  2 // Zeilen-Index 1
  3 // Zeilen-Index 2
  4 // Zeilen-Index 3
  5 // Zeilen-Index 3

TStringList: Strings sortieren:

<Bezeichner>->Sort();

// Mit 'Sort' werden die Strings im TStringList-Objekt
// in aufsteigender Reihenfolge sortiert

/* Beispiel 1: */

// Das TStringList-Objekt unsortiert:
strList_Test:
  4 // Zeilen-Index 0
  5 // Zeilen-Index 1
  3 // Zeilen-Index 2
  1 // Zeilen-Index 3
  2 // Zeilen-Index 4

// TStringList-Objekt sortieren
strList_Test->Sort();

// Das TStringList-Objekt sortiert:
strList_Test:
  1 // Zeilen-Index 0
  2 // Zeilen-Index 1
  3 // Zeilen-Index 2
  4 // Zeilen-Index 3
  5 // Zeilen-Index 4

Eigenschaften von TStringList:

Spoiler anzeigen

Anzahl der Strings im TStringList-Objekt:

int <Bezeichner> = <Bezeichner>->Count;

/* Beispiel 1: */
strList_Test->Add("4");
strList_Test->Add("5");
strList_Test->Add("3");
strList_Test->Add("1");
strList_Test->Add("2");

// Anzahl der Strings im TStringList-Objekt = 5
int iListCnt = strList_Test->Count;

Strings im TStringList-Objekt bearbeiten / abfragen:

String <Bezeichner> = <Bezeichner>->Strings[<Index>];
(String) <Bezeichner>->Strings[<Index>] = <Bezeichner>;
(String) <Bezeichner>->Strings[<Index>] = "<Wert>";

// jeden String im TStringList-Objekt verändern
for (int i = 0; i < iListCnt; ++i)
{
  strList_Test->Strings[i] = "Index: " + String(i);
}

// Das TStringList-Objekt sieht dann wie folgt aus:
strList_Test:
  Index: 0 // Zeilen-Index 0
  Index: 1 // Zeilen-Index 1
  Index: 2 // Zeilen-Index 2
  Index: 3 // Zeilen-Index 3
  Index: 4 // Zeilen-Index 4

TStringList: doppelte Strings:

<Bezeichner>->Duplicates = <Wert>;

// Die Eigenschaft 'Duplicates' legt fest, ob zu einer sortierten Liste
// String-Duplikate (identische Stringliterale) hinzugefügt
// werden können

// '<Wert>' legt dabei die Aktion fest, die ausgeführt werden soll,
// wenn ein String mehrfach zu einer sortierten Liste hinzugefügt
// werden wird

/* Beispiel 1: */

// dupIgnore - Der Versuch, der sortierten Liste ein
// String-Duplikat hinzuzufügen, wird ignoriert
strList_Test->Duplicates = dupIgnore;

// dupError - Der Versuch, der sortierten Liste ein
// String-Duplikat hinzuzufügen, führt zu einer Exception
strList_Test->Duplicates = dupError;

// dupAccept - doppelte Strings in der sortierten Liste
// sind erlaubt
strList_Test->Duplicates = dupAccept;

TStringList: einen einzelnen String durch ein Trennzeichen trennen:

(char) <Bezeichner>->Delimiter = '<einzelnes Zeichen>'; // Trennzeichen

// Die Eigenschaft 'DelimitedText' stellt alle Strings im TStrings-Objekt
// in einem einzigen String dar.
// Durch Zuweisung eines Strings kann dieser getrennt werden und
// wird somit in einzelne Strings zerlegt
(String) <Bezeichner>->DelimitedText = <Bezeichner>;

/* Beispiel 1: */

// Trennzeichen = ',' (Komma)
strList_Test->Delimiter = ',';

// String zum Zerlegen - getrennt durch das Trennzeichen (Delimiter)
String strCut = "Das,ist,ein,Beispiel";

// String zerlegen
strList_Test->DelimitedText = strCut;

// Das TStringList-Objekt sieht dann wie folgt aus:
strList_Test:
  Das       // Zeilen-Index 0
  ist       // Zeilen-Index 1
  ein       // Zeilen-Index 2
  Beispiel  // Zeilen-Index 3

TStringList: Strings im Format "Bezeichner=Wert" (INI-Datei):

// Bezeichner (den Teil des Strings vor dem '=') in
// Zeile <Index> ermitteln
String <Bezeichner> = <Bezeichner>->Names[<Index>];

// Wert (den Teil des Strings nach dem '=') auslesen
String <Bezeichner> = <Bezeichner>->Values["<Name des Bezeichners>"];
/* Beispiel 1: */

// Das TStringList-Objekt sieht wie folgt aus:
strList_Test:
  Test1=a // Zeilen-Index 0
  Test2=b // Zeilen-Index 1
  Test3=c // Zeilen-Index 2

// Bezeichner auslesen
String strBezeichner1 = strList_Test->Names[0]; // = Test1
String strBezeichner2 = strList_Test->Names[1]; // = Test2
String strBezeichner3 = strList_Test->Names[2]; // = Test3

// Werte auslesen - manuell
String strWert1 = strList_Test->Values["Test1"]; // = a
String strWert2 = strList_Test->Values["Test2"]; // = b
String strWert3 = strList_Test->Values["Test3"]; // = c

// Werte auslesen - mit den ermittelten Bezeichnern
String strWert1 = strList_Test->Values[strBezeichner1]; // = a
String strWert2 = strList_Test->Values[strBezeichner2]; // = b
String strWert3 = strList_Test->Values[strBezeichner3]; // = c

// nur um es genauer zu zeigen
String strGesamt = strWert1 + strWert2 + strWert3; // = abc

Ich hoffe das Tutorial hat euch geholfen!