1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:

procedure TForm1.BtnListItemAddClick(Sender: TObject);
var
    rawModeData: TRawModeData;
    li:TListItem;
begin
  rawModeData := TRawModeData.Create;    // instanz eigener Struktur anlegen
  li := LstModes.Items.Add();            // neues lsitenelement anlegen
  li.Data := @rawModeData;               // pointer zur instanz speichern
  li.ImageIndex := -1;
  LstModes.ItemIndex := LstModes.Items.Count-1;  // neues element selektieren
  BtnListItemChangeClick(sender);                // und routine zum ändern aufrufen
end;

procedure TForm1.BtnListItemChangeClick(Sender: TObject);
var item : TListItem;
    rawModeData:PRawModeData;
    mode:integer;
    pulse:integer;
begin
  item := LstModes.Selected;
  if item <> nil then
  begin
    rawModeData := PRawModeData(item.Data);
    rawModeData^:= createRawModeFromConfig(); // befüllt struktur
    item.Caption := 'test'
 end;

end;

procedure TForm1.LstModesSelectItem(Sender: TObject; Item: TListItem;
  Selected: Boolean);
var   modeData:TRawModeData;
begin
   if Item<>nil then
   begin
     modeData := PRawModeData(item.Data)^;
     rawModeToConfig(modeData);
   end;
end;					

1:

  li.Data := @rawModeData;               // pointer zur instanz speichern					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:

procedure TfrmVirtualTreesSmallExampleMain.FormCreate(Sender: TObject);
begin
  FMyData := TObjectList<TExampleData>.Create(True);
  FMyData.Add(TExampleData.Create('Test', 'a'));
  FMyData.Add(TExampleData.Create('Test2', 'b'));
  FMyData.Add(TExampleData.Create('Test3', 'c'));
  vstExample.NodeDataSize := SizeOf(TExampleData);
  ReloadData;
end;

procedure TfrmVirtualTreesSmallExampleMain.FormDestroy(Sender: TObject);
begin
  FMyData.Free;
end;

procedure TfrmVirtualTreesSmallExampleMain.ReloadData;
var
  CurrentData: TExampleData;
begin
  vstExample.ChildCount[vstExample.RootNode] := 0;
  for CurrentData in FMyData do
    vstExample.AddChild(vstExample.RootNode, CurrentData);
end;

procedure TfrmVirtualTreesSmallExampleMain.vstExampleGetText(Sender: TBaseVirtualTree;
  Node: PVirtualNode; Column: TColumnIndex; TextType: TVSTTextType;
  var CellText: string);
begin
  case Column of
    0: CellText := PExampleData(vstExample.GetNodeData(Node)).ExampleData1;
    1: CellText := PExampleData(vstExample.GetNodeData(Node)).ExampleData2;
  end;
end;					

1:
2:
3:

var rawModeData: PRawModeData;

  new(rawModeData);					

1:
2:
3:
4:
5:
6:
7:
8:
9:

TRawModeData* rawModeData = new RawModeData();  // heapobjekt mit defaultkonstruktor
rawModeData->irgendwas = 6;  //dereferenzierung und memberzugriff

TRawModeData localData(5); // stackobjekt mit speziellem konstruktor
*rawModeData = localData;  // kopieren des lokalen objektes an die Speicherstelle, auf die der Zeiger zeigt.

void* genericPointer = rawModeData; //pointer in typfreien Pointer speichern

rawModeData = (TRawModeData*)genericPointer ; // casten des generischen pointers auf Typbehafteten Pointer					

1:
2:
3:
4:
5:
6:
7:
8:

function TForm1.createRawModeFromConfig():TRawModeData;
var r:TRawModeData;
begin
 r := TRawModeData.Create();
 // ...
 createRawModeFromConfig := r;
 // muss ich hier r wieder Zerströren?
end;					

1:
2:
3:
4:
5:

void test ()
{
  IrgendEineKlasse stackisntanz; // <- defaultkonstructur
  // ..
} // <- beim verlassen wird Destructor aufgerufen					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

// Eintragen:
var
  Obj: TMyClass;
begin
  Obj:= TMyClass.Create;
  ListItem.Data:= Pointer(Obj);  // Delphi will einen Untyped Pointer

// auslesen
var
  Obj: TMyClass;
begin
  Obj:= TMyClass(ListItem.Data);  // "Dieser Pointer zeigt auf eine Instanz"

// ersetzen
var
  Obj: TMyClass;
begin
  Obj:= TMyClass(ListItem.Data);  // "Dieser Pointer zeigt auf eine Instanz"
  Obj.Free;                        // altes freigeben (das würdest du auch beim Item löschen verwenden)

  Obj:= TMyClass.Create;          // neues erstellen, hier könnte die Funktion stehen
  ListItem.Data:= Pointer(Obj);    // und wieder eintragen					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

PMyRecord = ^TMyRecord;
TMyRecord = record {...} end;

// Eintragen:
var
  Rec: PMyRecord;
begin
  New(Rec);
  ListItem.Data:= Rec;

// auslesen
var
  Rec: PMyRecord;
begin
  Rec:= PMyRecord(ListItem.Data);  // "Dieser Pointer zeigt auf diese Datenstruktur"
  Rec^.Attribut:= 42;

// ersetzen
var
  Rec: PMyRecord;
begin
  Rec:= PMyRecord(ListItem.Data);  // "Dieser Pointer zeigt auf diese Datenstruktur"
  Dispose(Rec);                    // altes freigeben (das würdest du auch beim Item löschen verwenden)

  New(Rec);                        // neues erstellen, hier könnte die Funktion stehen
  ListItem.Data:= Rec;    // und wieder eintragen					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

PMyRecord = ^TMyRecord;
TMyRecord = record {...} end;

// Eintragen:
var
  Flags: DWORD;
begin
  ListItem.Data:= Pointer(Flags);   // gewöhnlicher cast

// auslesen
var
  Flags: DWORD;
begin
  Flags:= DWORD(ListItem.Data);

// ersetzen: einfach
var
  newFlags: DWORD;
begin
  ListItem.Data:= Pointer(newFlags);					

1:
2:
3:
4:
5:
6:
7:
8:
9:

{$if CompilerVersion < 21} // vor Delphi 2010, da NativeInt in 2007 und 2009 kaputt war
type
  NativeInt = LongInt;
{$ifend}

var
  Flags: NativeInt;
begin
  Flags := NativeInt(ListItem.Data);