Pointer aus SendMessage nicht dereferenzierbar?

[erik-17]

Guten Abend :)

Ich versuche momentan einen Pointer, der auf einen Record zeigt, mithilfe von SendMessage/PostMessagen von einem Thread an die Main-Unit zu senden. Getestet ist es noch nicht, weil der Thread noch nicht vernünftig mit der Main-Unit läuft (bin da noch am programmieren). Wenn ich jetzt die Ereignisbearbeitungs-Methode (für die Message) schreiben will, dann möchte ich den Pointer ja dereferenzieren, damit ich an die Werte des Records rankomme.
Der Compiler spuckt mir immer Fehler aus...:

Delphi-Quellcode:

//Mein Record: (Sowohl im Thread als auch im Main bekannt)
TimeBinar = record
         Stunden  : array[1..5] of boolean;
         Minuten  : array[1..6] of boolean;
         Sekunden : array[1..6] of boolean;
end;

//Das Senden...
PostMessage(Form1.Handle,WM_TIME_ANNOUNCING,1,Integer(@PTimeBinar));
PostMessage(Form1.Handle,WM_TIME_ANNOUNCING,1,Integer(PTimeBinar)); //ohne "@" -> "Ungültige Typumwandlung"

//... und das Empfangen:
procedure TForm1.OnTimeAnnounce(var Msg: TMessage);
var p : TimeBinar;
begin
case Msg.WParam of
1 : begin
         p := TimeBinar(Msg.LParam^); //Zeigertyp erwartet
         p := TimeBinar(Msg.LParam);  //Ungültige Typumwandlung
         p := Msg.LParam^; //Zeigertyp erwartet
         p := Msg.LParam; //Inkompatible Typen "TimeBinar" und "Integer"
...

Mach ich das soweit erstmal richtig (bin auf dem Gebiet noch Anfänger) oder muss man das ganz anders machen? Und wie komm ich schlussendlich an das Record ran?

Danke im voraus und guten Abend noch :D

[Aphton]

Delphi-Quellcode:

PTimeBinar = ^TTimeBinar;
TTimeBinar = record
  Stunden  : array[1..5] of boolean;
  Minuten  : array[1..6] of boolean;
  Sekunden : array[1..6] of boolean;
end;

PostMessage(Form1.Handle,WM_TIME_ANNOUNCING,1,Integer(@PTimeBinar));

procedure TForm1.OnTimeAnnounce(var Msg: TMessage);
var
  p : TTimeBinar;
begin
case Msg.WParam of
  1: 
  begin
    p := PTimeBinar(Msg.LParam)^;
  end;
{..}

PTimeBinar(Msg.LParam)^ =
Interpretiere Msg.LParam als PTimeBinar - bei diesem Typ handelt es sich um nen Pointer, weswegen auch folgender Schritt möglich ist - und dereferenziere diesen nach p (heißt kopiere den Inhalt des Pointers in die lokale, nichtsaussagende Variable p)

Falls du keine Berechnungen damit durchführen musst bzw. wenn die Änderung auch die echten Daten betreffen darf, wäre es besser, direkt mit Pointern zu arbeiten - sprich du machst folgendes:

Delphi-Quellcode:

var
  p : PTimeBinar;
{..}
  p := PTimeBinar(Msg.LParam);

EDITH:
Übrigens, in Delphi gibts die Konvention, Typendeklarationen mit T zu beginnen wie korrigierterweise TTimeBinar.
Dasselbe gilt auch für Pointer zu den definierten Typen, die..
mit P wie in PTimeBinar begonnen werden und
direkt über die Typendeklaration ihren Platz zu suchen haben...

Warum ich dir das klar mache.. nun

Delphi-Quellcode:

  PostMessage(Form1.Handle,WM_TIME_ANNOUNCING,1,Integer(PTimeBinar));

Ne Variable, die nen Typnamen hat ("PTimeBinar"), ist verwirrend und irritierend =P

Edith, die Zweite; Potenzieller Bug:
Verwende keine Pointer auf lokale Variablen, da zur Laufzeit diese immer wieder überschrieben werden können (zB. durch ständiges aufrufen derselben Methode, wo sich die Daten, auf die gepointet wird, befinden)!

[Luckie]

Delphi-Quellcode:

type
  TMyRecord = record
    MyInt: Integer;
    MyShortString: ShortString;
  end;
  PMyRecord = ^TMyRecord;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
    MyRecord: PMyRecord;
  public
    { Public declarations }
    procedure WndProc(var Message: TMessage); override;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

const
  WM_PUFF = WM_USER + 1;

procedure TForm1.Button1Click(Sender: TObject);
begin
  MyRecord := new(PMyRecord);
  MyRecord.MyInt := 42;
  MyRecord.MyShortString := 'Keine Panik.';
  SendMessage(Form1.Handle, WM_PUFF, 0, Integer(MyRecord));  // Kein @. MyRecord ist schon ein Pointer.
end;

procedure TForm1.WndProc(var Message: TMessage);
var
  MyInt: Integer;
  MyShortString: ShortString;
begin
  inherited;
  case Message.Msg of
    WM_PUFF: begin
        MyInt := PMyRecord(Message.LParam).MyInt;
        MyShortString := PMyRecord(Message.LParam).MyShortString;
        ShowMessage(IntToStr(MyInt) + ' ' + MyShortString);
        Dispose(MyRecord);
      end;
  end;
end;

[himitsu]

Und statt

Delphi-Quellcode:

Integer(MyRecord)

besser

Delphi-Quellcode:

LPARAM(MyRecord)

verwenden.
(Ja, es gibt für den Parameter lParam einen gleichnamigen Typen LPARAM :roll: )



Ich wisst doch, daß irgendwer auf die saublöde Idee kam den Integer nicht mit auf 64 Bit anwachsen zu lassen.



PS:

Delphi-Quellcode:

Integer(@PTimeBinar)

ist ein Zeiger auf den Typen,
also kann man das nicht zu einer Variable dereverentieren, sondern nur wieder zu einem Typen.

Oder wie unbd wo ist PTimeBinar deklariert?

PSS:
PostMessage, bzw. das auszuführende Ereignis wird nicht sofort ausgeführt, sondern nur an die MessageQueue angehängt.
Wenn man nun den Zeiger auf eine lokale Variable übergibt, dann knallt es natürlich, wenn diese Variable inzischen freigeben ist, da die Prozedur beendet wurde.

[Aphton]

Zitat:

Ich wisst, doch, daß irgendwer auf die saublöde Idee kam den Integer nicht mit auf 64 Bit anwachsen zu lassen.

Ach, echt? Ironie?
Ich dachte immer, Integer sei ein generischer Typ und würde somit auch "mitwachsen"..
Falls Ironie - ist LPARAM nicht als Integer definiert? =P

[Luckie]

LPARAM ist als LongInt definiert.

Delphi-Quellcode:

LPARAM = Longint;

[himitsu]

jupp, war früher mal so (LongInt).

Nun in D2010 ist es so

Delphi-Quellcode:

INT_PTR = Integer;
LPARAM = INT_PTR;

Und ich hoffe mal, Emba ist so schlau das INT_PTR auf 64 Bit anzupassen, wenn man für 64 bit kompiliert. :stupid:

[Luckie]

Ok, war noch Delphi 7 (startet schneller als mein D2006 ;) ).

[erik-17]

Ok, danke für eure Antworten :)

Ich habs vorwiegend durch Luckie's Quellcode gelöst.

Die Lösung schaut nun so aus:

Delphi-Quellcode:

type
  PTimeBinar = ^TTimeBinar;
  TTimeBinar = record
         Stunden : array[1..5] of boolean;
         Minuten : array[1..6] of boolean;
         Sekunden : array[1..6] of boolean;
  end;

  TTimeThread = class(TThread)

  private
     TimeBinar : PTimeBinar;
  protected
    procedure Execute; override;
  end;

implementation
uses Unit1;

procedure TTimeThread.Execute;
begin
     TimeBinar := new(PTimeBinar);
     [...]
          SendMessage(Form1.Handle,WM_TIME_ANNOUNCING,0,LPARAM(TimeBinar));
end;

/// Quellcode der MainUnit:

procedure TForm1.OnTimeAnnounce(var Msg: TMessage);
var p : PTimeBinar;
begin
case Msg.WParam of
0 : begin
         p := PTimeBinar(Msg.LParam);
         TueEtwas(p);
    end;

Um das ganze Problem mal allgemein zu beschreiben: Ich will mir eine binäre Uhr bauen. Dazu lass ich einen Thread dauerhaft laufen, der mir die Zeit in die Binärfaktoren zerlegt und danach 100ms pausiert. Um dann nicht ständig mit einem Timer von der MainUnit aus die Werte auszulesen, sende ich aus dem Thread nach erfolgreicher Zerlegung die Message mit dem Pointer. Ist meiner Meinung nach viel eleganter :D