Zeichenfolgentypen in Delphi

Wie bei jeder Programmiersprache in DelphiVariablen sind Platzhalter zum Speichern von Werten. Sie haben Namen und Datentypen. Der Datentyp einer Variablen bestimmt, wie die Bits, die diese Werte darstellen, im Speicher des Computers gespeichert werden.

Wenn wir eine Variable haben, die ein Array von Zeichen enthält, können wir sie als vom Typ deklarierenString.
Delphi bietet eine gesunde Auswahl an Zeichenfolgenoperatoren, -funktionen und -prozeduren. Bevor wir einer Variablen einen String-Datentyp zuweisen, müssen wir die vier String-Typen von Delphi gründlich verstehen.

Einfach gesagt, Kurze Schnur ist ein gezähltes Array von (ANSII) Zeichen mit bis zu 255 Zeichen in der Zeichenfolge. Das erste Byte dieses Arrays speichert die Länge der Zeichenfolge. Da dies der Hauptzeichenfolgentyp in Delphi 1 (16-Bit-Delphi) war, ist der einzige Grund für die Verwendung von Short String die Abwärtskompatibilität.
Um eine Variable vom Typ ShortString zu erstellen, verwenden wir:

var s: ShortString; s: = 'Delphi-Programmierung'; 





instagram viewer
// S_Length: = Ord (s [0])); // das ist das gleiche wie Länge (n)

Das s Variable ist eine Short-String-Variable, die bis zu 256 Zeichen aufnehmen kann. Ihr Speicher besteht aus statisch zugewiesenen 256 Bytes. Da dies normalerweise verschwenderisch ist - unwahrscheinlich, dass sich Ihre kurze Saite auf die maximale Länge ausbreitet - Sekunde Bei der Verwendung von Short Strings werden Subtypen von ShortString verwendet, deren maximale Länge zwischen 0 und 0 liegt 255.

var ssmall: String [50]; ssmall: = 'Kurze Zeichenfolge mit bis zu 50 Zeichen';

Dadurch wird eine Variable namens aufgerufen klein deren maximale Länge beträgt 50 Zeichen.

Hinweis: Wenn wir einer Short String-Variablen einen Wert zuweisen, wird der String abgeschnitten, wenn er die maximale Länge für den Typ überschreitet. Wenn wir kurze Zeichenfolgen an eine Delphi-Routine zur Manipulation von Zeichenfolgen übergeben, werden diese in und aus langen Zeichenfolgen konvertiert.

Delphi 2 wurde zu Object Pascal gebracht Lange Schnur Art. Lange Zeichenfolge (in Delphis Hilfe AnsiString) stellt eine dynamisch zugewiesene Zeichenfolge dar, deren maximale Länge nur durch den verfügbaren Speicher begrenzt ist. Alle 32-Bit-Delphi-Versionen verwenden standardmäßig lange Zeichenfolgen. Ich empfehle, lange Saiten zu verwenden, wann immer Sie können.

var s: String; s: = 'Der s-String kann eine beliebige Größe haben ...';

Das s Die Variable kann von Null bis zu einer beliebigen praktischen Anzahl von Zeichen reichen. Die Zeichenfolge wächst oder schrumpft, wenn Sie ihr neue Daten zuweisen.

Wir können jede Zeichenfolgenvariable als Array von Zeichen verwenden, das zweite Zeichen in s hat den Index 2. Der folgende Code

s [2]: = 'T';

weist zu T. zum zweiten Zeichen os der s Variable. Nun die wenigen der ersten Charaktere in s aussehen wie: TTe s str ....
Seien Sie nicht irreführend, Sie können s [0] nicht verwenden, um die Länge der Zeichenfolge zu sehen. s ist kein ShortString.

Da die Speicherzuweisung von Delphi vorgenommen wird, müssen wir uns nicht um die Speicherbereinigung kümmern. Bei der Arbeit mit langen (Ansi) Strings verwendet Delphi die Referenzzählung. Auf diese Weise ist das Kopieren von Zeichenfolgen für lange Zeichenfolgen schneller als für kurze Zeichenfolgen.
Referenzzählung am Beispiel:

var s1, s2: String; s1: = 'erste Zeichenfolge'; s2: = s1;

Wenn wir einen String erstellen s1 Delphi weist der Zeichenfolge genügend Speicher zu. Wenn wir kopieren s1 zu s2Delphi kopiert den Zeichenfolgenwert nicht in den Speicher, sondern erhöht nur die Referenzanzahl und ändert die s2 auf den gleichen Speicherort wie zeigen s1.

Um das Kopieren beim Übergeben von Zeichenfolgen an Routinen zu minimieren, verwendet Delphi die Copy-on-Write-Technik. Nehmen wir an, wir sollen den Wert von ändern s2 Zeichenfolgenvariable; Delphi kopiert die erste Zeichenfolge an einen neuen Speicherort, da die Änderung nur s2 und nicht s1 betreffen sollte und beide auf denselben Speicherort verweisen.

Breite Zeichenfolgen werden ebenfalls dynamisch zugewiesen und verwaltet, verwenden jedoch weder die Referenzzählung noch die Semantik beim Kopieren beim Schreiben. Breite Zeichenfolgen bestehen aus 16-Bit-Unicode-Zeichen.

Der von Windows verwendete ANSI-Zeichensatz ist ein Einzelbyte-Zeichensatz. Unicode speichert jedes Zeichen im Zeichensatz in 2 Bytes anstelle von 1. Einige Landessprachen verwenden ideografische Zeichen, für die mehr als die von ANSI unterstützten 256 Zeichen erforderlich sind. Mit der 16-Bit-Notation können wir 65.536 verschiedene Zeichen darstellen. Die Indizierung von Multibyte-Strings ist seitdem nicht zuverlässig s [i] repräsentiert das i-te Byte (nicht unbedingt das i-te Zeichen) in s.

Wenn Sie Wide-Zeichen verwenden müssen, sollten Sie eine Zeichenfolgenvariable vom Typ WideString und Ihre Zeichenvariable vom Typ WideChar deklarieren. Wenn Sie eine breite Zeichenfolge zeichenweise untersuchen möchten, prüfen Sie, ob mehrere Zeichen vorhanden sind. Delphi unterstützt keine automatischen Typkonvertierungen zwischen Ansi- und Wide-String-Typen.

var s: WideString; c: WideChar; s: = 'Delphi_ Guide'; s [8]: = 'T'; //s='Delphi_TGuide';

Eine null- oder nullterminierte Zeichenfolge ist ein Array von Zeichen, die durch eine Ganzzahl beginnend mit Null indiziert werden. Da das Array keinen Längenindikator hat, verwendet Delphi ASCII 0 (NULL; # 0) Zeichen zum Markieren der Grenze der Zeichenfolge.
Dies bedeutet, dass es im Wesentlichen keinen Unterschied zwischen einer nullterminierten Zeichenfolge und einem Array [0..NumberOfChars] vom Typ Char gibt, wobei das Ende der Zeichenfolge mit # 0 markiert ist.

Wir verwenden nullterminierte Zeichenfolgen in Delphi, wenn wir Windows-API-Funktionen aufrufen. Mit Object Pascal können wir vermeiden, mit Zeigern auf nullbasierte Arrays herumzuspielen, wenn nullterminierte Zeichenfolgen mithilfe des PChar-Typs verarbeitet werden. Stellen Sie sich ein PChar als Zeiger auf eine nullterminierte Zeichenfolge oder auf das Array vor, das eine darstellt. Weitere Informationen zu Zeigern finden Sie unter:Zeiger in Delphi.

Zum Beispiel die GetDriveType Die API-Funktion bestimmt, ob ein Laufwerk ein Wechsel-, Fest-, CD-ROM-, RAM-Laufwerk oder Netzwerklaufwerk ist. Das folgende Verfahren listet alle Laufwerke und ihre Typen auf dem Computer eines Benutzers auf. Platzieren Sie eine Button- und eine Memo-Komponente in einem Formular und weisen Sie einen OnClick-Handler einer Button zu:

Verfahren TForm1.Button1Click (Absender: TObject); var
Laufwerk: Char; DriveLetter: String [4]; Startzum Laufwerk: = 'A' zu 'Z' tunStart
DriveLetter: = Drive + ': \'; Fall GetDriveType (PChar (Laufwerk + ': \')) von
DRIVE_REMOVABLE: Memo1.Lines. Add (DriveLetter + 'Floppy Drive'); DRIVE_FIXED: Memo1.Lines. Add (DriveLetter + 'Fixed Drive'); DRIVE_REMOTE: Memo1.Lines. Add (DriveLetter + 'Network Drive'); DRIVE_CDROM: Memo1.Lines. Hinzufügen (DriveLetter + 'CD-ROM-Laufwerk'); DRIVE_RAMDISK: Memo1.Lines. Add (DriveLetter + 'RAM Disk'); Ende; Ende; Ende;

Wir können alle vier verschiedenen Arten von Saiten frei mischen. Delphi wird es am besten geben, einen Sinn für das zu finden, was wir versuchen zu tun. Die Zuweisung s: = p, wobei s eine Zeichenfolgenvariable und p ein PChar-Ausdruck ist, kopiert eine nullterminierte Zeichenfolge in eine lange Zeichenfolge.

Zusätzlich zu vier Zeichenfolgendatentypen verfügt Delphi über drei Zeichentypen: Verkohlen, AnsiChar, undWideChar. Eine Zeichenfolgenkonstante der Länge 1, z. B. 'T', kann einen Zeichenwert bezeichnen. Der generische Zeichentyp ist Char, was AnsiChar entspricht. WideChar-Werte sind 16-Bit-Zeichen, die gemäß dem Unicode-Zeichensatz geordnet sind. Die ersten 256 Unicode-Zeichen entsprechen den ANSI-Zeichen.