Array of String mit Pointer

[wschrabi]

Hallo, also ich verwnende TsiLang von SICOmponentes. So weit so gut.
Doch ich hab einen Array of String und da muss man lt. FAQ https://www.tsilang.com/tsilang-faq/#11 mit @ arbeiten:
Doch wieso bekomme ich hier eine ACCESS VIOLATION?

Delphi-Quellcode:

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
         sD1 : string[23]         =  ' 1-Nacken              ';
         sD2 : string[23]         =  ' 2-Triceps             ';
         sD3 : string[23]         =  ' 4-Rücken oben         ';
         sD4 : string[23]         =  ' 9-Rücken unten        ';
         sD5 : string[23]         =  '13-O.Schenkel h        ';
         sD6 : string[23]         =  '15-Wade                ';
         sD7 : string[23]         =  ' 6-Brust seitl.        ';
         sD8 : string[23]         =  '10-Hüfte               ';
         sD9 : string[23]         =  '12-O.Schenkel s        ';
         sD10: string[23]         =  ' 5-Brust vorne         ';
         sD11: string[23]         =  ' 3-Biceps              ';
         sD12: string[23]         =  ' 7-Bauch oben          ';
         sD13: string[23]         =  ' 8-Bauch unten         ';
         sD14: string[23]         =  '11-O.Schenkel v        ';
         sD15: string[23]         =  '14-O.Schenkel i        ';
         sD16: string[23]         =  '-----------------------';

      lTxt : array[1..15] of Pstring    = (@sD1 ,
                                          @sD2 ,
                                          @sD3 ,
                                          @sD4 ,
                                          @sD5 ,
                                          @sD6 ,
                                          @sD7 ,
                                          @sD8 ,
                                          @sD9 ,
                                          @sD10,
                                          @sD11,
                                          @sD12,
                                          @sD13,
                                          @sD14,
                                          @sD15 );

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var
 s : string;
begin
   s:=ltxt[1]^;
   ShowMessage(format('lTxt[1]= %s',[s]));
end;

end.

[HolgerX]

Hmm..

könnte es sein, das ein 'string[23]' anders behandelt wird wie ein 'string' und dann nicht mehr kompatible zu PString ist?

Ist ein 'string[23]' nicht eine Art Shortstring und dann intern ein Konstantenarray of Char und kein dynamischer 'string' mehr?

Ich hab einfach mal die [23] weggelassen und es kommt keine Exception mehr ;)

Delphi-Quellcode:

         sD1 : string = ' 1-Nacken ';
         sD2 : string = ' 2-Triceps ';
         sD3 : string = ' 4-Rücken oben ';
         sD4 : string = ' 9-Rücken unten ';
         sD5 : string = '13-O.Schenkel h ';
         sD6 : string = '15-Wade ';
         sD7 : string = ' 6-Brust seitl. ';
         sD8 : string = '10-Hüfte ';
         sD9 : string = '12-O.Schenkel s ';
         sD10: string = ' 5-Brust vorne ';
         sD11: string = ' 3-Biceps ';
         sD12: string = ' 7-Bauch oben ';
         sD13: string = ' 8-Bauch unten ';
         sD14: string = '11-O.Schenkel v ';
         sD15: string = '14-O.Schenkel i ';
         sD16: string = '-----------------------';

      lTxt : array[1..15] of PString = (@sD1 ,
                                          @sD2 ,
                                          @sD3 ,
                                          @sD4 ,
                                          @sD5 ,
                                          @sD6 ,
                                          @sD7 ,
                                          @sD8 ,
                                          @sD9 ,
                                          @sD10,
                                          @sD11,
                                          @sD12,
                                          @sD13,
                                          @sD14,
                                          @sD15 );

Alternativ, wenn Du die Länge behalten möchtest, dann einen eigenen Typ definieren:

Delphi-Quellcode:

type
  TMyString = string[23];
  PMyString = ^TMyString;
var
     sD1 : TMyString = ' 1-Nacken ';
     sD2 : TMyString = ' 2-Triceps ';
     sD3 : TMyString = ' 4-Rücken oben ';
     sD4 : TMyString = ' 9-Rücken unten ';
     sD5 : TMyString = '13-O.Schenkel h ';
     sD6 : TMyString = '15-Wade ';
     sD7 : TMyString = ' 6-Brust seitl. ';
     sD8 : TMyString = '10-Hüfte ';
     sD9 : TMyString = '12-O.Schenkel s ';
     sD10: TMyString = ' 5-Brust vorne ';
     sD11: TMyString = ' 3-Biceps ';
     sD12: TMyString = ' 7-Bauch oben ';
     sD13: TMyString = ' 8-Bauch unten ';
     sD14: TMyString = '11-O.Schenkel v ';
     sD15: TMyString = '14-O.Schenkel i ';
     sD16: TMyString = '-----------------------';

      lTxt : array[1..15] of PMyString = (@sD1 ,
                                          @sD2 ,
                                          @sD3 ,
                                          @sD4 ,
                                          @sD5 ,
                                          @sD6 ,
                                          @sD7 ,
                                          @sD8 ,
                                          @sD9 ,
                                          @sD10,
                                          @sD11,
                                          @sD12,
                                          @sD13,
                                          @sD14,
                                          @sD15 );

[himitsu]

Zitat:

Ist ein 'string[23]' nicht eine Art Shortstring und dann intern ein Konstantenarray of Char und kein dynamischer 'string' mehr?

Um genauer zu sein ist String[L] als "Typ" ist ein ShortString mit bestimmter Länger (ShortString selbst ist 255 lang)
und PString ist ein Pointer auf String, was ein LongString ist, hier genauer ist es ein Alias für einen UnicodeString (seit Delphi2009) und davor was es ein AnsiString. (ganz früher, vor Delphi2, war String der ShortString, auch wenn er damals noch nicht so heiß)

ShortString ist ein "statisches Array" mit LängenByte (im Char 0 ... drin fangen Strings bei 1 an zu zählen), also der ShortString ist quasi ein "Record",
und LongStrings sind aufgemotzte "dynamische Arrays" mit Referenzzählung, abschließender #0#0 uvm, also quasi ein Pointer.

[wschrabi]

Danke jetzt ist es mir klar :wink: