Problem mit Record-Parametern an MethodenPointer bzw. FunktionsPointer

[TiGü]

Es ist zu warm um groß Erklärung zu suchen und aufzuschreiben, aber ich habe hier einen Workaround für dich (Ausschnitt auf das Wesentliche zum Kopieren):

Delphi-Quellcode:

Function MyFunktion(CONST Rec: DoubleDouble): DoubleDouble;
// Hoch 2: --> X*X;
Begin
  WriteLn('MyFunktion wurde aufgerufen!');

  WriteLn('Rec.X[0] = ', Rec.X[0]);
  WriteLn('Rec.X[1] = ', Rec.X[1]);

  ClearRec(Result);

  Result.X[0]:= Rec.X[0]*Rec.X[0];
  Result.X[1]:= Rec.X[1]*Rec.X[1];
End;{MyFunktion}
{--------------}

function MyFunktionEx(Self: Pointer; const Rec: DoubleDouble): DoubleDouble;
Begin
  WriteLn('MyFunktionEx wurde aufgerufen!');
  Result := MyFunktion(Rec);
End;

VAR
  A    : TTestObject;
  MPtr : Tf_x_Methode;  // MethodenPointer
  FuPtr: Tf_x_Function; // FunktionsPointer

  X, Y: DoubleDouble;


Begin
  Try
    A:= TTestObject.Create;
    Try
       X.X[0]:= 2;
       X.X[1]:= 3;

       ClearRec(Y);

       WriteLn;

      // 3: EXTERNEN MethodenPointer als FunktionsPointer verwenden:
      WriteLn('3: Funktion wird über den EXTERNEN MethodenPointer aufgerufen:');
      // A:= TTestObject.Create; ist nötig!!!!

     // EXTERNEN MethodenPointer in FunktionsPointer umwandeln:
      TMethod(MPtr).Code:= @MyFunktionEx; // wird vom Compiler NICHT gesetzt, weil EXTERNER MethodenPointer!
      TMethod(MPtr).Data:= @A; // selber setzen

      ClearRec(Y);
      Y:= MPtr(X); // Ein Record mit Zufallsinhalt wird an die Funktion übergeben!
      Print('Y = X^2 = ', Y);

      WriteLn;
      WriteLn;

      WriteLn('4: Funktion wird über den MethodenPointer des Objektes aufgerufen:');

      TMethod(A.Ptr).Code:= @MyFunktionEx; // TMethod(Ptr).Data wird vom Compiler NICHT automatisch gesetzt!
      TMethod(A.Ptr).Data:= @A; // Sonst ist Record X ist in der Funktion gar NICHT existent!

      ClearRec(Y);
      Y:= A.Ptr(X);   // Ein Record mit Zufallsinhalt wird an die Funktion übergeben!
      Print('Y = X^2 = ', Y);

Code:

3: Funktion wird über den EXTERNEN MethodenPointer aufgerufen:
MyFunktionEx wurde aufgerufen!
MyFunktion wurde aufgerufen!
Rec.X[0] =  2.00000000000000E+0000
Rec.X[1] =  3.00000000000000E+0000
Y = X^2 = 4 + 9


4: Funktion wird über den MethodenPointer des Objektes aufgerufen:
MyFunktionEx wurde aufgerufen!
MyFunktion wurde aufgerufen!
Rec.X[0] =  2.00000000000000E+0000
Rec.X[1] =  3.00000000000000E+0000
Y = X^2 = 4 + 9

[Andreas13]

Vielen Dank, TiGü: Es funktioniert!
Nach Deiner Idee konnte ich den Aufruf sogar noch weiter vereinfachen, indem ich direkt MyFunktion(..) um den Eintrag Self: Pointer; erweitert habe:

Delphi-Quellcode:

Function MyFunktion(Self: Pointer; CONST Rec: DoubleDouble): DoubleDouble;
. . .

Zwar kapiere ich immer noch nicht, warum der mit einfachen Datentypen gängige Weg mit Records nur mit Self funktioniert, aber im Moment ist für mich nur wichtig, daß es klappt. Ich muß ja nicht alles verstehen...

Danke Dir noch einmal: Du hast mir sehr geholfen!
Gruß, Andreas
PS:
So funktionieren alle vier Varianten!

[Andreas13]

Sorry, ich war wohl etwas voreilig und muß meine letzte pauschale Aussage etwas relativieren: Variante 2, also die direkte Verwendung des FunktionsPointers funktioniert doch NICHT (mehr).

Abhilfe: Stets MethodenPointer benutzen! Ein auf FunktionsPointer gecasteter externer MethodenPointer funktioniert nämlich immer korrekt.
Vorteil: Die Erzeugung des Objectes durch TTestObject.Create; ist nicht nötig.

Andreas

[himitsu]

Oder die Generics -> reference to

Alle "offiziellen" Möglichkeiten, ohne an der automatischen Typbehandlung rumzupfuschen:

Delphi-Quellcode:

type
  TTest = class  
    function A(): Boolean;
    function B(): Boolean; virtual;  // bzw. overload oder auch dynamic
    class function C(): Boolean;
    class function D(): Boolean; virtual;  // bzw. overload oder auch dynamic
    class function E(): Boolean; static;
  end;
  
function F(): Boolean;

{
  E entspricht F
  A = C (nur eben TClass statt TObject, beim Self)
  A und C auch mit Data/Self=NIL möglich
}

var
  X: function(): Boolean;  // E oder F
  Y: function(): Boolean of object;  // A, B, C oder D
  Z: reference to function(): Boolean;  // alles, inkl. anonymer Methoden (nicht direkt als VAR ... muß einen TYPE haben)
  O: TTest;
  L: class of TTest;


O := TTest.Create;

X := TTest.E;  // oder L.E oder O.E inkl. O=nil
X := F;
Y := O.A;  // auch O=nil
Y := O.B;
Y := TTest.C;  // oder L.C oder O.C inkl. L=nil 
Y := TTest.D;  // oder L.D oder O.D
Z := egal was

[Andreas13]

Danke, Himitsu!
Ich werde versuchen, Deinen recht konzentrierten Code zu verstehen. Leider habe ich noch etliche Lücken bezüglich Generics, anonymer Methoden etc.
Gruß, Andreas

[himitsu]

Bei "reference to procedure" werden intern quasi die Generics verwendet ... du selbst hast hier nichts damit zu tun ... macht alles der Compiler von selbst.

[freimatz]

Ja genau. Einfach "reference to" dazu und Hirn abschalten