C-dll Speicheradressen

[Johannes G.]

Ich habe noch eine Frage zu den Pointern. Das mit dem Pointer auf Array funktioniert alles bestens.
Doch wenn sich die Funktion ein einer Klasse befindet, zeigt der übergebene Pointer nicht mehr auf das definierte Array (sondern irgendwo hin).

Warum ist das so?? Was kann ich dagegen unternehmen??

Hier mein kleines Testprogramm:

Delphi-Quellcode:

unit newt;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;


 type

  PTArray = ^Tarray; //Pointer auf Tarray
  Tarray = array[0..1] of double;

  PTArray2 = ^Tarray2;
  Tarray2 = array[0..1] of double;

     
  Tnewt = function (n: integer; var x: Tarray; f : Pointer; jaco:Pointer;
  kmax,prim : integer; pfile:Pchar; var fval: Tarray2; var anziter: Pinteger;
  eps: double ): integer; cdecl;


   TForm1 = class(TForm)
    Button1: TButton;
    Edit1: TEdit;
    Edit2: TEdit;
    Edit3: TEdit;
    Edit4: TEdit;
    Label1: TLabel;
    procedure Button1Click(Sender: TObject);

  private

    function f(x: PTarray; y: PTarray2) : integer; cdecl;
  
    function dnewt(n: integer;  var x: Tarray; f : Pointer; jaco:Pointer;
    kmax,prim : integer; pfile:Pchar; var fval: Tarray2; var anziter: Pinteger;
    eps: double): integer; cdecl;
     
  public

  end;


var
  Form1: TForm1;

implementation

{$R *.dfm}

//hier zeigt x nicht auf das Array Tarray!!!!!! Selbes gilt für y

function TForm1.f( x: PTarray;  y: PTarray2): integer; cdecl;
 begin

      y[0] := x[0]*x[0]/4 + x[1]*x[1]/5 + x[0] - 0.5;
      y[1] := x[0]*x[0]/4 + x[1]*x[1]/2 + x[1] - 0.5;
      result := 0;
 end;


//Funktion Newton-Iteration:
function TForm1.dnewt(n: integer;  var x: Tarray; f : Pointer; jaco:Pointer;
  kmax,prim : integer; pfile:Pchar; var fval: Tarray2; var anziter: Pinteger;
  eps: double): integer; cdecl;

var 
  Newton: Tnewt;
  Handle:THandle;

begin
  Handle:=LoadLibrary('C:\Delphi-Testprogramme\CNum.dll');

  if Handle <> 0 then begin
    @Newton:= GetProcAddress(Handle, 'newt');
    if @Newton  <> nil then begin
      result := newton(n,x,f,jaco,kmax,prim,pfile,fval,anziter,eps);
    end;
    FreeLibrary(Handle);
  end;
end;



procedure TForm1.Button1Click(Sender: TObject);
var
x : Tarray;
fval: Tarray2;
Fehler: integer;
anz: Pinteger;

begin

//Wert zuweisen
x[0] := 0.5;
x[1] := 0.5;

//Funktionsaufruf (lösen des Glsys in der Funktion f)
Fehler:= dnewt(2,x,@TForm1.f,nil,4,0,Nil,fval,anz,1E-8);

end;

end.

Bin wirklich um jeden Hinweis dankbar!

Gruß Johannes

[Zacherl]

Wenn du die Funktion in eine Klasse packst, wird ein versteckter "Self" Parameter vom Compiler hinzugefügt. Das kannst du verhindern, indem du die Methode als class function Blabla(): Integer; static; deklarierst (+ cdecl natürlich, wenn gewünscht).

[Johannes G.]

Super, vielen Dank!
Mein Testprogramm läuft jetzt.

Bei der Implementierung in mein Hauptprogramm habe ich aber jetzt das Problem, dass in dieser (mit class function()) deklarierter Funktion weitere proceduren und Funktionen aufgerufen werden, von denen aus weiter Funktionen aufgerufen werden usw. ...

Fehlermeldung: Diese Form des Methodenaufrufs ist nur für Klassenmethoden oder Konstruktoren zulässig.

Ich müsste also die aufzurufende Funktion ebenfalls als class function deklarieren und somit auch alle, in weiteren Schritten aufgerufenen Funktionen. Da dies allerdings sehr viele sind, möchte ich das vermeiden.
Weiters sind dann die Variablen die im Vorfeld in dieser Unit berechnet wurden nicht mehr Verfügbar: [dcc32 Fehler] uGRK.pas(1183): E2124 Instanzenelement 'EWI_im' in diesem Zusammenhang nicht verfügbar

Zitat aus der Hilfe:

Zitat:

Sie können außerdem auf keine Instanz-Member zugreifen. (Sie können aber auf Klassenfelder, Klasseneigenschaften und Klassenmethoden zugreifen

Gibt es noch andere Möglichkeiten, die Methode ohne Self Parameter zu übergeben, z.B. mit einem Compilerschalter o.ä??
Oder auf die Speicheradresse der Variablen ohne den Self Parameter zuzugreifen?

Gruß Johannes

[Zacherl]

Auf globale Variablen solltest du eigentlich zugreifen können. Dass der Zugriff auf Instanzmethoden nicht funktioniert, ist ja ganz logisch. Die aktuelle Instanz wird ja im Self Parameter übergeben. Fehlt dieser, ist auch die Instanz zur Laufzeit unbekannt bzw. existiert nichtmal.

Mit class function und static deklarierte Methoden sind im Grunde nichts anderes als globale freistehende Funktionen. Die Klassenzugehörigkeit wird hier nur zur logischen Gruppierung verwendet. Einen Klassenkontext (Instanz, Felder, etc.) kann es hier nicht geben.

Sämtliche anderen Funktionen auch als class function zu deklarieren, ist kein Problem und sogar die korrekte Vorgehensweise, solange du keinen Kontext benötigst. Ist das doch der Fall, wirst du leider die Signatur der C Funktion anpassen müssen.