Pointer verstehen

[wiwa]

Versuche gerade zwangsläufig Zeiger kennen zu lernen...
Wie gehe ich mit sowas um???

Delphi-Quellcode:

type
   TArray = array of string;
   pdata = ^tdata;
   tdata = record
     p: ^TArray;
   end;}


var
  fdat:pdata;

...

Wie komme ich an "p" ran, was muß ich wie mit New() erzeugen
und wie habe ich späterZugriff darauf ???
Oder macht sowas gar keinen Sinn ???
Wer lässt sich auf tiefere Diskussion mit einem Ahnungslosen ein?!

[Giantics]

Warum speicherst du ein Pointer auf ein dynamisches Array?
Das dyn. Array selber muss ja auch erst erstellt werden. Ein Zeiger is da doch irgendwie überflüssig oder?
Ich würde das so machen:

Delphi-Quellcode:

type
   TArray = array of string;
   pdata = ^tdata;
   tdata = record
     p: TArray;
   end;


var
  fdat:pdata;

begin
  New(fdat);
  SetLength(fdat.p,5);  // z.b 0 bis 4.
  //Zugriff mit:
  fdat.p[2]:= 'Hallo';

  //am Schluss nicht vergessen:
  SetLength(fdat.p,0);
  Dispose(fdat);  // freigeben

...

[dizzy]

Zitat von wiwa:

Delphi-Quellcode:

type
   TArray = array of string;
   pdata = ^tdata;
   tdata = record
     p: ^TArray;
   end;}


var
  fdat:pdata;

...

Du erstellst hier einen Pointer auf einen Pointer auf einen Pointer auf einen Pointer...

Weil:
array of ... ist ein Pointer.
^irgendwas ist ein Pointer, somit ist ^TArray schon ein Pointer auf einen Pointer.
record ist ein Pointer, also ist pdata ein Pointer auf einen Pointer, der einen Pointer auf einen Pointer enthält

Mir erschließst sich die Sinnhaftigkeit dessen grad nicht

[paelesoft]

Code:

begin
  New(fdat);
  New(fdat^.p);
  SetLength(fdat^.p^,3);
  fdat^.p^[2]:='ganz schön kompliziert';
end.

[Hansa]

Du meinst wohl eher eine Liste. Was du vor hast ist schon eine bessere Lösung, als ein dyn. Array. Das ganze sieht normalerweise so aus :

Delphi-Quellcode:

Zeiger = ^Daten;

  Daten = record
    nr,
    artID : integer;       (* wird benötigt für Lagerbestände etc.,       *)
                           (* um das erneute Lesen von Artikeln zu sparen *)
    bez   : string [25];
    Nachfolger,
    Vorgaenger : Zeiger;
  end;

  TListe = class
  public
    Aktuell,
    First,   // First = links ; Last = rechts
    Last : Zeiger;
    Anzahl : integer;
    constructor create;
    procedure Auflegen;
  end;

Allerdings muß ich dich warnen : solltest su völlig ahnungslos sein, dann mußt du dich mit der Theorie schon etwas beschäftigen. Vorerst dazu nur noch folgendes : wie man sieht wird Zeiger als ^Daten deklariert. "Daten" werden aber erst später deklariert. Und die Liste, die damit erzeugt wird ist völlig dynamisch und doppelt verkettet. Das bedeutet, sie kann vorwärts oder rückwärts durrchgeackert werden. Wie gesagt, so ganz einfach ist das nicht.

[wiwa]

Hi,
danke für die fülle an hochinteressanten antworten und aspekten zu dem thema.
sinn und hintergrund ist eine meinem ^unwissenden hirn entsprungene idee:
ich entdecke aktuell die VirtualTreeView komponente von Mike Lischke (leicht
im web zu finden:
http://www.soft-gems.net/http://www.soft-gems.net/)
wer die kennt, kann das problem vielleicht nachvollziehen: es geht um eine
TreeView-Komponente, die in fast allen einzelheiten und details beeinflussbar ist.
die enthaltenen daten werden über einen statischen record implementiert. solange die daten
statisch sind, ist das ganze recht einfach zu handhaben. möchte man allerdings
dynamisch daten zur laufzeit in welcher form auch immer einfügen bleibt eigentlich
nur die pointer-strategie. der record ansich ist von dem konzept der VST-Komponente ein pointer
um ihn nun um dynamische daten zu erweitern benötige ich weitere pointer (^ auf ^ auf ^),
so hab ich mir das jedenfalls gedacht:


type
TArray = array of string;
pdata = ^tdata;
tdata = record
p: ^TArray;
end;

Was spricht dagegen?

Gruß
Willi

[wiwa]

nochmal in dieser sache:
das problem scheint mir, dass der inhalt des record der VST Komponente zur design-
u. laufzeit fest vorgegeben sein muss, daher schließt sich p:TArray eigentlich aus,
da p hier noch keine größe hat, oder seh ich das falsch?
p:^TArray hat aber eine feste größe und gilt somit als "statisch", was dann später
ausserhalb des record mit p^ passier ist eine andere (vielleicht die nächste) frage.

Gruß
Willi

[maximov]

Moin,

records haben immer eine feste grösse, das liegt in ihrer natur, da sie zB. mit einer simplen multiplikation in einem array addressierbar sind etc. Also wie oben schon angemerkt ist ein dyn.Array bereits ein pointer und muss somit nicht doppelt gemoppelt werden.

[sakura]

Tue mir mal noch einen Gefallen und erweitere bitte Deine Überschrift. Pointer ??? ist etwas zu allgemein.

......

[paelesoft]

Hallo wiwa,

TArray ist in Wirklichkeit schon eine Art Zeiger, da es ein dynamisches
Array ist, auf das mit einem Zeiger referenziert wird.

Überprüfen kannst du es zB wenn du SizeOf(TArray) aufrufst. Dann erhältst du das
Ergebnis "4" (Größe eines Pointers).
Noch ein "Beweis" dafür ist folgender Versuch:

Bitte ein Formular mit einem Button und einem Editierfeld (Edit1) erstellen.
In die OnClick-Behandlung des Buttons folgenden Code einfügen:

Delphi-Quellcode:

var S : array of Char;
    T : PChar;
begin
  Setlength(S,6);
  S[0]:='H';
  S[1]:='a';
  S[2]:='l';
  S[3]:='l';
  S[4]:='o';
  S[5]:=#0;
  GetMem(T,6);
  Move(Pointer(S)^ ,T^,6);
  Edit1.Text:=StrPas(T);
  FreeMem(T,6);
end;

Das Ergebnis ist "Hallo"