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