1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

type
  TTreeListRecord = record
    ColValue0: string;
    ColValue1: string;
  end;

  ...
  private
    fTreeListRecord: ^TTreeListRecord;
    fTreeList: TList;

  ...
  SetData(fTreeList, fTreeListRecord); // Aufruf in der anderen Unit (siehe unten..)                    

1:
2:
3:
4:
5:
6:

  function TChecklistePrintProcessMgr.SetData(aTreeList: TList;
    aTreeListRecord: TTreeListRecord): boolean;
  begin
    fTreeList := aTreeList;
    fTreeListRecord := aTreeListRecord;
  ...                    

1:
2:
3:
4:
5:
6:

 function TChecklistePrintProcessMgr.SetData(aTreeList: TList;   
    aTreeListRecord: TTreeListRecord): boolean;   
  begin   
    fTreeList := aTreeList;   
    fTreeListRecord := aTreeListRecord;   
  ...                    

1:

SetData(fTreeList, fTreeListRecord^);                    

1:

Inkompatible Typen: 'Unit1.TTreeListRecord' und 'Unit2.TTreeListRecord'                    

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:

unit Unit1;

interface

uses
  Unit2,
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    btnCopyRecord: TButton;
    procedure btnCopyRecordClick(Sender: TObject);
  private
    fMyRec: TMyRec;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.btnCopyRecordClick(Sender: TObject);
var
  lMyClass: TMyClass;
begin
  lMyClass := TMyClass.Create;
    fMyRec.Test := 'TEST';
  lMyClass.SetData( fMyRec );
  lMyClass.SetData( @fMyRec );
  FreeAndNil( lMyClass );
end;


end.                    

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:

unit Unit2;

interface

type
  PMyRec = ^TMyRec;
  TMyRec = record
    Test: string;
  end;

  TMyClass = class
  public
    procedure SetData(aMyRec: TMyRec); overload;
    procedure SetData(aMyRec: PMyRec); overload;
  end;

implementation

uses
  Dialogs;

{ TMyClass }

procedure TMyClass.SetData(aMyRec: TMyRec);
begin
  MessageDlg( aMyRec.Test, mtInformation, [mbOK], 0 );
end;

procedure TMyClass.SetData(aMyRec: PMyRec);
begin
  MessageDlg( aMyRec.Test, mtInformation, [mbOK], 0 );
end;

end.                    

1:
2:
3:
4:

procedure TMyClass.SetData(aMyRec: PMyRec);
begin
  MessageDlg( aMyRec^.Test, mtInformation, [mbOK], 0 );
end;                    

1:
2:
3:
4:
5:

type
  TTreeListRecord = record
    Value: String;
    IsChild: Boolean;
  end;                    

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

  procedure TChecklistePrintProcessMgr.SetData(tv: TTreeView);
  var
    i: Integer;
    ptlr: ^TTreeListRecord;
  begin
    for i:=0 to tv.Items.Count-1 do
    begin
      new(ptlr);
      ptlr^.Value:=tv.Items[i].Text;
      ptlr^.IsChild:=tv.Items[i].Parent<>nil;
      fTreeList.Items.Add(ptlr);  
        // fTreeList muss in TChecklistePrintProcessMgr.Create
        // erzeugt worden sein 
    end;
    // [...] 
  end;                    

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

#include <iostream>

struct foo
{
    char foo;
};

int main()
{
    foo *p;
    foo f;
    p = (foo *)malloc( sizeof(foo) );
    p->foo = 'a';
  std::cout << p->foo << std::endl;
  f = *p;
  std::cout << f.foo << std::endl;
  std::cout << ((foo)*p).foo << std::endl;
  std::cout << (*p).foo << std::endl;
  return 0;
}                    

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:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:

...

private
    fTreeListRecord: TTreeListRecord;

...

//******************************************************************************
function TForm1.InitChecklistPrintDlg(aTreeList: TdxTreeList): boolean;
var
  lNodeCount: integer;
  lItemCount: integer;
  lCounter: integer;
  lCounter2: integer;
  lValue: string;
  lNode: TdxTreeListNode;
begin
  result := false;
  lChecklistePrintProcessMgr := nil;
  try
    lChecklistePrintProcessMgr := TChecklistePrintProcessMgr.Create;
    // ParentCount der TreeList
    lNodeCount := aTreeList.Count;

    // Record wird gefüllt
    for lCounter := 0 to lNodeCount-1 do begin
      // Parents
      lNode := aTreeList.Items[lCounter];
      lValue := lNode.Values[0] + ' ' + lNode.Values[2];

      //New(fTreeListRecord);
      with fTreeListRecord do begin
        Value := lValue;
        IsChild := false;
      end;
      lChecklistePrintProcessMgr.AddToList(fTreeListRecord);

      // ItemCount der TreeList
      lItemCount := lNode.Count;

      // Childs
      for lCounter2 := 0 to lItemCount-1 do begin
        lValue := lNode.Items[lCounter2].Values[2];

        //New(fTreeListRecord);
        with fTreeListRecord do begin
          Value := lValue;
          IsChild := true;
        end;

        lChecklistePrintProcessMgr.AddToList(fTreeListRecord);
      end;
    end;

    result := true;
  except
    // Hier später Fehlerbehandlung
  end;
end;                    

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:
40:
41:
42:

PTreeListRecord = ^TTreeListRecord;
  TTreeListRecord = record
    Value: string;
    IsChild: boolean;
  end;

  ...

  private
    TreeListRecord: ^TTreeListRecord;

  ...

//******************************************************************************
// Aufruf um den aktuellen Inhalt des Records in eine Liste zu speichern
function TChecklistePrintProcessMgr.AddToList(
  aTreeListRecord: TTreeListRecord): boolean;
begin
  result := false;
  try
    fTreeList.Add(@aTreeListRecord);
    result := true;
  except
    // Hier später Fehlerbehandlung 
  end;
end;

//******************************************************************************
// Hier wird versucht den Inhalt der Liste auszulesen und ihn wieder auf den
// Record aufzuteilen damit Value und IsChild getrennt ausgelesen werden können
function TChecklistePrintProcessMgr.PrepareData: boolean;
var
  lTreeListCount: integer;
begin
  Result := false;
  lTreeListCount := fTreeList.Count;

  for lCounter := 0 to lTreeListCount-1 do begin

    TreeListRecord := fTreeList.Items[lCounter];
    ShowMessage(TreeListRecord^.Value);
  end;                    

1:

Im Projekt Project1.exe ist eine Exception der Klasse EExternalException aufgetreten. Meldung: 'Externe Exception 80000001'. Prozeß wurde angehalten. Mit Einzelne Anweisung oder Start fortsetzen.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

//******************************************************************************
// Aufruf um den aktuellen Inhalt des Records in eine Liste zu speichern
function TChecklistePrintProcessMgr.AddToList( [b]var[/b] aTreeListRecord: TTreeListRecord): boolean;
begin
  result := false;
  try
    fTreeList.Add(@aTreeListRecord);
    result := true;
  except
    // Hier später Fehlerbehandlung 
  end;
end;                    

1:

aTreeListRecord: PTreeListRecord                    

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:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  PTreeRec = ^TTreeRec;
  TTreeRec = record
    Idx: string;
  end;

  TForm1 = class(TForm)
    Memo1: TMemo;
    procedure FormShow(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    fList: TList;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
var
  lIdx: integer;
  lRec: PTreeRec;
begin
  fList := TList.Create;

  for lIdx := 0 to 100 do
  begin
    New( lRec );
    lRec^.Idx := IntToStr( lIdx );
    fList.Add( lRec )
  end;
end;

procedure TForm1.FormDestroy(Sender: TObject);
var
  lIdx: integer;
begin

  if Assigned( fList ) then
  begin
    for lIdx := 0 to (fList.Count - 1) do
    begin
      Dispose( fList.Items[lIdx] );
    end;
    FreeAndNil( fList );
  end;
end;

procedure TForm1.FormShow(Sender: TObject);
var
  lIdx: integer;
begin
  for lIdx := 0 to (fList.Count -1) do
  begin
    Memo1.Lines.Add( PTreeRec(fList.Items[lIdx])^.Idx );
  end;
end;

end.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

    
function TChecklistePrintProcessMgr.AddToList(
  aTreeListRecord: TTreeListRecord): Boolean;
var
  pNewRec: ^TTreeListRecord;
begin
  new(pNewRec);
  pNewRec^:=aTreeListRecord;
  try
    fTreeList.Add(pNewRec);
    Result:=true;
  except
    Result:=false;
  end;
end;