Delphi: Strings in Records größer als 255 Zeichen

Question

Gibt es eine Möglichkeit, Strings in Datensätzen größer als 255 Zeichen zu bekommen?

EDIT:

Ich habe so etwas wie die folgenden:

TQuery = Record 
    Action: string[255]; 
    Data: string; 
end; 

wenn ich jetzt sagen:

Test: TQuery; 
Test.Data := 'ABCDEFGHIJKLMN...up to 255...AISDJIOAS'; //Shall be 255 chars 

Es funktioniert nicht, und der Compiler beschwert sich ... Wie um das zu beheben?

Answer 1

Wenn Sie in der Lage sein möchten, Ihren Datensatz in eine Datei zu schreiben, können Sie Ihre Zeichenfolge als ein Array von ansichar zum Beispiel definieren. Sie können es danach wie eine Schnur behandeln.

Beispiel:

program StrInRecTest; 
{$APPTYPE CONSOLE} 
uses SysUtils; 

type 
    TStringRec= 
    packed record 
     S:array[0..1023] of ansichar; 
    end; 

var 
    StringRec:TStringRec; 
    F:File of TStringRec; 
begin 
    StringRec.S := 'Hello'; 
    WriteLn(StringRec.S); 
    WriteLn('First char is:'+StringRec.S[0]); // watch out with this 


    // now let's try saving this to a file and reading it back... 

    // make a long string with x-es 
    FillChar(StringRec.S,Length(StringRec.S),'X'); 
    StringRec.S[High(StringRec.S)] := #0; // terminate the string 

    WriteLn(StringRec.S); 

    // write to a file 
    AssignFile(F,'tmp.txt'); 
    ReWrite(F); 
    Write(F,StringRec); 
    CloseFile(F); 

    WriteLn; 

    // read from file 
    AssignFile(F,'tmp.txt'); 
    Reset(F); 
    Read(F,StringRec); 
    CloseFile(F); 

    WriteLn(StringRec.S); // yay, we've got our long string back 

    ReadLn; 
end. 

Answer 2

Normalerweise ja. Sie müssen nichts Spezielles tun, solange Sie den normalen String-Typ (oder die anderen langen String-Typen) und nicht ShortString verwenden.

type 
    TMyRec = record 
    Value: string; 
    end; 

In der Praxis hängt es ab, was Sie mit dem Datensatz tun möchten. Wenn Sie etwas in eine Datei blockieren-schreiben möchten oder den Datensatz zu einer DLL-Funktion zur Verfügung stellen, müssen Sie in char-Arrays wechseln:

type 
    TMyRec = record 
    Value: array[0..1023] of Char; 
    end; 

Answer 3

Wenn Sie meinen, sie in eine Datenbank zu speichern, dann ist es völlig abhängig von der Datenbank, die Sie verwenden. Mehrere Datenbanken unterstützen Zeichenketten bis zu 8K Länge; und SQL 2005 eingeführt varchar (MAX), die eine Grenze von hat, glauben 2GB. MySql 5 scheint für denselben Datentyp auf etwa 65 K beschränkt zu sein.

Einige der älteren erlauben jedoch nur [var] char (255).

Womit versuchen Sie es zu tun?

Answer 4

In Delphi gibt es verschiedene Arten von string:

• Short - bis zu 255 Zeichen
• Ansi - bis zu 2^31 Chars
• Wide - bis zu 2^31 WideChars

Zeichenfolge wird normalerweise als AnsiString interpretiert. AnsiString & WideStrings sind Zeiger auf den Speicher, in dem die Zeichenfolge gespeichert ist. Der Compiler zaubert dort etwas, um Ressourcen zu sparen.

Wenn Sie also eine Zeichenfolge in einen Datensatz eingeben, erhalten Sie zwar das gewünschte Ergebnis, aber ich schätze, die Größe des Operators auf dem Datensatz schlägt fehl.

---

Thx zu Smasher für Hinweis: Dies wird aus Delphi 2006 Hilfe zitiert. Verschiedene Delphi-Versionen verhalten sich möglicherweise anders.

Answer 5

Delphi und die drei Saiten

Es war einmal, in den frühen Tagen von pascal, dort, wo kurze Strings. Sie bestanden aus einem Block von Bytes mit einer maximalen Größe von 256.Das erste Byte betrug die Länge Byte:

5, H, e, l, l, o 

Sie feste Zeichenfolgen speichern Speicher definieren könnte:

a: string[5]; 

Windows verwendet C-Strings, die ein Zeiger auf einen Speicherblock mit einem 0-Zeichen abgeschlossen . Diese Zeichenfolgen waren nicht auf 255 Bytes beschränkt. Zuerst wurden sie als PChar (Zeiger auf Char) bereitgestellt. Später wurde die Standardzeichenfolge jedoch als Zeichenfolge vom Typ C interpretiert. Sie könnten immer noch shortstrings verwenden:

a: string[22]; 
b: ShortString; 
c: string; // C (Delphi) string 

Mit Delphi 2009 wurde Unicode eingeführt. Jetzt war jede Zeichenfolge eine Unicode-Zeichenfolge. Dies ist ein Zeiger auf ein Stück Speicher mit Unicode-Zeichen. Wir haben immer noch den ShortString-Typ. Auf die alten Ansi-Zeichenfolgen kann mit AnsiString oder PAnsiChar zugegriffen werden.

Jetzt, da Strings Zeiger sind, gibt es keine Begrenzung für die Größe. String-Literale sind jedoch immer noch auf 255 Zeichen beschränkt.