C-dll Speicheradressen

[Johannes G.]

Hallo miteinander,

Ich bin neu hier im Forum und ca. seit einem halben Jahr mit Delphi beschäftigt :).

Nun zu meinem Problem, bei dem ich einfach nicht weiter komme.

Ich habe in meinem Delphi-Programm eine .dll (Numerik-Bibliothek) eingebunden, die in AnsiC erstellt wurde.
Im Benutzerhandbuch der dll ist die Funktion definiert:

Code:

int newt ( int n,
double x[],
int f( double x[], double y[]),
int jaco( double x[], double *df[]),
int kmax,
int prim,
char *pfile,
double fval[],
int *anziter,
double eps
);

mit folgender Beschreibung zu jaco:
"int jaco( double x[], double *df[])
Funktion zur Berechnung der Jacobi–Matrix. Bei Vorgabe des Vektors x werden die Werte der partiellen Ableitungen der Funktion f nach den Komponenten von x berechnet und in der n × n–Matrix df abspeichert."

Als Übergabeparameter übergebe ich der Funktion (newt) meine Funktion jaco:

Code:

function Jac(var x: Tarray; var df: TMatrix) : integer; cdecl;
begin

  df[0][0]^ := x[0] / 2 + 1;
  df[0][1]^ := 2 * x[1] / 5;
  df[1][0]^ := x[0] / 2;
  df[1][1]^ := x[1] + 1;

  result :=  0;
end;

Die Typdeklarationen von Tarray und TMatrix sind folgendermaßen:

Code:

Tarray = array[0..1] of double;
TMatrix = array[0..1,0..1]  of Pdouble;

die dll-Funktion newt übergibt mir also mit der variablen df ein Speicherstellen der Matrix, die ich mit df[][]^ beschreiben will (Wert zuweisen).

Mein Problem ist, dass die Speicherstellen von df[1][0] und df[1][1] so aussehen:
$ABABABAB und eine Fehlermeldung kommt, wenn ich darauf schreiben will.

Die Speicherstellen von df[0][0] und df[0][1] werden von der dll korrekt übergeben, zb.: $263BC8....

Wenn ich mir über einen Pointer die Adresse anzeigen lassen z.B. @df[1][0], bekomme ich eine vermeidlich korrekte Adresse (ähnlich wie von df[0][0] und df[0][1]). Wenn ich aber die Matrix über diese Adresse beschreibe, mag das meine dll-Funktion nicht.

Leider kenne ich mich in C mit der Speicherverwaltung nicht aus, sodass ich auf eure Hilfe angewiesen bin.

Hier noch die C-Codestelle, bei der der Speicher für diese Matrix reserviert wird:

Code:

/* Speicher fuer Jacobi Matrix     */
  jmat    = (REAL **)vmalloc(vmblock, MATRIX,  n, n);

Vielen Dank im Voraus für eure Hilfe!

Gruß Johannes

[Fritzew]

nur auf den ersten Blick:

Das ist falsch, ändere

Delphi-Quellcode:

Tarray = array[0..1] of double;
TMatrix = array[0..1,0..1] of Pdouble;

zu

Delphi-Quellcode:

Tarray = array[0..1] of double;
TMatrix = array[0..1,0..1] of double; // ist auch Double

Hintergrund die funktion erwartet einen Pointer auf ein Array of Double nicht einen Pointer auf ein Array of Pointer

[Johannes G.]

Hallo Fritz,

danke für deine schnelle Antwort!

Leider funktioniert das ganze noch nicht. Wenn ich aus dem Pdouble ein double mache, also die Matrix zurück gebe, kommt die Fehlermeldung 'Access Violation at ....: read of the address ...'

Eine andere Funktion der gleichen DLL ist auch so aufgebaut, nur mit dem Unterschied keine Matrix(*df[]) sondern eine normale Variable (*y). Ich habe es bei dieser Funktion auch so gemacht, dass ich auf diese Adresse schreibe mit y^:=, siehe unten. Hat alles wunderbar funktioniert!

Code:

function f(k:integer; x: Tarray; y: Pdouble): integer; cdecl;
 begin
    if k=0 then
    begin
      y^ := x[0]*x[0]/4 + x[1]*x[1]/5 + x[0] - 0.5;
    end else
    begin
      y^ := x[0]*x[0]/4 + x[1]*x[1]/2 + x[1] - 0.5;
    end;
    result := 0;
 end;

C-Funktionsaufruf:

Code:

int f( int k, double x[], double *y)

Mit der Beschreibung der Funktion:

Code:

Funktion, welche das n × n–System beschreibt.
In
int k;
double x[], y;
...
f( k, x, &y);
...
wird der Wert der k-ten Komponentenfunktion des Systems an der Stelle x
(Vektor der Länge n) berechnet und das Ergebnis (also eine Zahl) nach y geschrieben.
(Im Gegensatz zum Verfahren newt berechnet hier die Funktion f
nur eine Komponente des nicht linearen Systems!)

Ich stehe im Moment ziemlich auf der Leitung wie ich das mit dem Pointer auf das Array (bzw. Matrix) realisieren soll.
Vielleicht hat noch jemand eine Idee?

Gruß Johannes

[Fritzew]

Code:

"int jaco( double x[], double *df[])

das ist auf Delphi Seite eigentlich

Delphi-Quellcode:

type
pDoubleArray = ^TdoubleArray;
tDoubleArray = array[0..0] of Double;

function Jaco(x : tDoubleArray;  df : pDoubleArray) : integer; cdecl;

[Johannes G.]

Danke, jetzt habe ich das mit dem Pointer auf ein Array verstanden :)

Ich habe mein Bsp. einwenig abgeändert, da der Pointer df auf die Matrix df[][] und nicht auf das Array x[] zeigen soll!

Code:

pMatrix = ^TMatrix;
  tMatrix = array[0..1,0..1] of Double;

Funktion jac:

Code:

function Jac(var x: Tarray; var df: pMatrix) : integer; cdecl;
begin

  df[0][0] := x[0] / 2 + 1;
  df[0][1] := 2 * x[1] / 5;
  df[1][0] := x[0] / 2;
  df[1][1] := x[1] + 1;

  result :=  0;
end;

Der ptr df zeigt jetzt auf den ersten Eintrag der Matrix df[0][0], die Adressen der anderen 3 Einträge sind jeweils um 8Byte dahinter (aneinander gefolgt). Ich denke das passt soweit!

Irgendwas stimmt aber trotzdem noch nicht. Wenn ich durch die Funktion debugge, öffnet sich am Ende der Reiter "CPU" mit folgender Zeile:

7775067D C605A592787700 mov byte ptr [$777892a5],$00 was hat das zu bedeuten?

Auch die Funktion newt der DLL gibt mir einen Fehler zurück: Matrix singulär. Heißt also, dass die Einträge der df-Matrix doch nicht am richtigen Platz landen :|

[Fritzew]

Zitat:

Zitat von Johannes G. (Beitrag 1384642)

Danke, jetzt habe ich das mit dem Pointer auf ein Array verstanden :)

Ich habe mein Bsp. einwenig abgeändert, da der Pointer df auf die Matrix df[][] und nicht auf das Array x[] zeigen soll!

Code:

pMatrix = ^TMatrix;
  tMatrix = array[0..1,0..1] of Double;

Funktion jac:

Code:

function Jac(var x: Tarray; var df: pMatrix) : integer; cdecl;
begin

  df[0][0] := x[0] / 2 + 1;
  df[0][1] := 2 * x[1] / 5;
  df[1][0] := x[0] / 2;
  df[1][1] := x[1] + 1;

  result :=  0;
end;

Der ptr df zeigt jetzt auf den ersten Eintrag der Matrix df[0][0], die Adressen der anderen 3 Einträge sind jeweils um 8Byte dahinter (aneinander gefolgt). Ich denke das passt soweit!

Irgendwas stimmt aber trotzdem noch nicht. Wenn ich durch die Funktion debugge, öffnet sich am Ende der Reiter "CPU" mit folgender Zeile:

7775067D C605A592787700 mov byte ptr [$777892a5],$00 was hat das zu bedeuten?

Auch die Funktion newt der DLL gibt mir einen Fehler zurück: Matrix singulär. Heißt also, dass die Einträge der df-Matrix doch nicht am richtigen Platz landen :|

Deine Jac stimmt nicht der erste Parameter ist kein var..........

[Johannes G.]

Das Stimmt, habe ich ausgebessert. Allerdings leider das gleiche Ergebnis...

[Zacherl]

Zitat:

Zitat von Johannes G. (Beitrag 1384644)

Das Stimmt, habe ich ausgebessert. Allerdings leider das gleiche Ergebnis...

Es sollte meiner Meinung nach entweder nur

Delphi-Quellcode:

pMatrix

oder

Delphi-Quellcode:

var TMatrix

sein. Edit: Ah nvm, habe die falsche Signatur angeschaut. Diese ist richtig?

Delphi-Quellcode:

int jaco( double x[], double *df[])

Arrays in C sind automatisch immer Zeiger. Also statt

Delphi-Quellcode:

dobule bla[]

könnte man in C auch einfach

Delphi-Quellcode:

double* bla

schreiben. Durch die spezielle Zeigerarithmetik in C darf der Array Operator auf jeden Zeiger angewendet werden und greift dabei auf den Speicher bei

Delphi-Quellcode:

Index * sizeof(ElementType)

zu. Ähnlich funktioniert ja auch Delphis

Delphi-Quellcode:

Inc

, wenn du es auf eine "typisierte Zeigervariable" z.b. PDobule anwendest. Der Zeiger würde dann automatisch um

Delphi-Quellcode:

SizeOf(Double)

erhöht werden.

Wenn du deinen eigenen Matrix Typ erstmal weglässt, funktioniert es dann folgendermaßen:

Delphi-Quellcode:

type
  PDoubleArray = ^TDoubleArray;
  TDoubleArray = array[0..0] of Double;

function Jaco(X: PDoubleArray; var DF: PDoubleArray): Integer; cdecl;

[Fritzew]

Zitat:

Zitat von Zacherl (Beitrag 1384645)

Arrays in C sind automatisch immer Zeiger. Also statt

Delphi-Quellcode:

dobule bla[]

könnte man in C auch einfach

Delphi-Quellcode:

double* bla

schreiben. Durch die spezielle Zeigerarithmetik in C darf der Array Operator auf jeden Zeiger angewendet werden und greift dabei auf den Speicher bei

Delphi-Quellcode:

Index * sizeof(ElementType)

zu. Ähnlich funktioniert ja auch Delphis

Delphi-Quellcode:

Inc

, wenn du es auf eine "typisierte Zeigervariable" z.b. PDobule anwendest. Der Zeiger würde dann automatisch um

Delphi-Quellcode:

SizeOf(Double)

erhöht werden.

Wenn du deinen eigenen Matrix Typ erstmal weglässt, funktioniert es dann folgendermaßen:

Delphi-Quellcode:

type
  PDoubleArray = ^TDoubleArray;
  TDoubleArray = array[0..0] of Double;

function Jaco(X: PDoubleArray; var DF: PDoubleArray): Integer; cdecl;

Jep so sollte es passen, Habe ich auch nicht mehr daran gedacht...

[Johannes G.]

Danke, hat jetzt geklappt mit dem Vektor x[] als Pointer.

Allerdings habe ich immer noch das Problem, dass mein Übergabepointer df nicht stimmt.
Dazu habe ich nach längerem stöbern noch folgende nützliche Information gefunden:

Code:

int jaco();                                          *
 *                jaco hat die Form:                        *
 *                                                                    *
 *                  int jaco (int n, REAL x[], REAL *mem[])           *
 *                  {                                                 *
 *                   REAL **df;                                       *
 *                   df = mem;                                        *
 *                   for (i = 0; i < n; i++)                          *
 *                      for (j = 0; j < n; j++)                       *
 *                         df[i][j] = ...;                            *
 *                   return (0);                                      *
 *                  }                                                 *
 *                                                                    *
 *               Dabei ist ... durch die partielle Ableitung der      *
 *               i-ten Funktionskomponente nach der j-ten x-Komponen- *
 *               te zu ersetzten. mem ist hierbei die Lokation fuer   *
 *               den Speicherbereich, der nach Ausfuehrung die        *
 *               Jacobimatrix beinhaltet[/B].

und folgender Hinweis zu Übergabe von Matrizen:

Zitat:

Da die Übergabe von zweidimensionalen Feldern (Matrizen) an Funktionen in AnsiC für Anwendungen
ziemlich ungeeignet ist, werden in der Bibliothek nicht die Matrizen selbst an die
Funktionen übergeben, sondern mittels eines Feldes von Zeigern die Anfangsadressen der einzelnen
Zeilen der Matrix.
Man muss also etwa neben einer m × n–Matrix selbst zusätzlich ein Feld der Länge m von
Zeigern definieren, wobei der i–te Zeiger auf die i–te Zeile der Matrix zeigt.

Es wird also das Feld von Zeigern an die Funktion übergeben und es wird davon ausgegangen,
dass die Zeiger der Reihe nach auf die Zeilen der Matrix zeigen."

Ich habe mal folgende Varianten ausprobiert, bin mir nicht sicher welche Variante die richtige ist:
1. Übergabe der Matrix df als Array von Pointern mit df:= [(AdresseZeile1,AdresseZeile2)]
und
2. Übergabe als Pointer auf das Array of Pointer.

Leider haben beide Varianten nicht funktioniert. Die DLL-Funktion gab mir bei Variante 1 als Rückgabewert 3 (Matrix sei singulär, was nicht sein kann) an.
Bei Variante 2 springt die DLL einen Iterationsschritt weiter, doch als nächster Startwert (Vektor x[]) kommt so ein Blödsinn raus, dass ich in Gleitkomma überlauf habe (irgendwas ^300):)

Hier noch meine Funktion:

Delphi-Quellcode:

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

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

  PTarrayofPointer = ^TarrayofPointer; //Pointer auf array of Pointer
  TarrayofPointer =  Array[0..1] of Pdouble; //Array of Pointer;

//  pMatrix = ^TMatrix;
  TMatrix = array[0..1,0..1] of PDouble;

Delphi-Quellcode:

function Jac( x: PTarray;  df: TarrayofPointer) : integer; cdecl;
var
JacMat: TMatrix;
i: integer;
Pinhalt:double;
begin
  //Speicher für Jacobimatrix anfordern
  new(JacMat[0][0]);
  new(JacMat[0][1]);
  new(JacMat[1][0]);
  new(JacMat[1][1]);

  //Jacobimatrix beschreiben
  JacMat[0][0]^ := x[0] / 2 + 1;
  JacMat[0][1]^ := 2 * x[1] / 5;
  JacMat[1][0]^ := x[0] / 2;
  JacMat[1][1]^ := x[1] + 1;


   df[0] := @jacMat[0]; //Adresse 1. Zeile der Jacobimatrix in ein Array of Pointer
   df[1] := @jacMat[1]; //Adresse 2. Zeile


  result :=  0;
end;

Wahrscheinlich mache ich bei der Adresszuweisung hier irgendwas falsch... :(

[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

Delphi-Quellcode:

class function Blabla(): Integer; static;

deklarierst (+

Delphi-Quellcode:

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

Delphi-Quellcode:

class function

und

Delphi-Quellcode:

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

Delphi-Quellcode:

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.