Autor Beitrag
shritis
Hält's aus hier
Beiträge: 5



BeitragVerfasst: Mi 24.08.05 10:04 
Hallo zusammen,

folgendes Problem: In einer C-DLL werden Berechnungen vorgenommen, deren Ergebnisse in einem double array gespeichert werden sollen. Die größe dieses Arrays wird durch die DLL bestimmt. Die Frage ist nun, wie ich diesen Rückgabewert in Delphi nutzen kann:

DLL-code:

ausblenden Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
DLLIMPORT double* testDoubleArray()
{
  int i = 0;
  int size = 10;
  //speicher reservieren
  double *dblArr = malloc(size * sizeof(double));
  for (i = 0; i < size; i++)
  {
    dblArr[i] = i/3.0; //nur zum testweisen erzeugen von Doubles
  }
  return(dblArr);
}


Wie müsste ich jetzt in Delphi diese Funktion nutzen? Wichtig ist, dass die Delphi-Prozedur nicht weiss, wie groß das zurückgegebene Array wird. Mit einem in Delphi initialisierten Array hab ich das schon hinbekommen. Die DLL mit konkreten Berechnungen wird noch geschrieben. Es geht also erstmal nur um die Möglichkeiten des Datenaustauschs.

Gibt es vielleicht irgendwo ein Tutorial, wo die verschiedenen Nutzungsarten von Datentypen zwischen C und Delphi zusammengefasst sind?

Vielen Dank schonmal im Voraus,
Robert
tommie-lie
ontopic starontopic starontopic starontopic starontopic starofftopic starofftopic starofftopic star
Beiträge: 4373

Ubuntu 7.10 "Gutsy Gibbon"

BeitragVerfasst: Mi 24.08.05 12:19 
So kannst du das gar nicht sinnvoll machen, es sei denn du gibst zusätzlich noch die Anzahl der Werte zurück (was übrigens üblich ist).
Man könnte es allerdings so machen wie einige Windows-API-Funktionen: Das Array wird um ein Element größer allokiert als man es eigentlich braucht. Das letzte Element wird dann auf 0 initialisiert. Dann kann man in Delphi mit einem Pointer auf Double (type PDouble = ^Double) arbeiten, und den immer um 1 erhöhen, bis man beim dereferenzieren auf 0 trifft. Das dürfte aber in diesem Fall eher unpraktikabel sein, denn wenn ein Ergebnis einer Berechnung 0 ist, wird dort bereits abgebrochen, obwohl danach noch weitere Ergebnisse kommen könnten. Sowas kann man daher nur dann anwenden, wenn die im Array enthaltenen Werte immer ungleich 0 sind, z.B. wenn man ein Pointer-Array zurückgeben will.
Bei den Fällen wie hier macht man es daher normalerweise etwas anders. Zum einen lässt man meist den Caller den Speicher allokieren, zum anderen benutzt man Pointer als Übergabewerte (in Delphi var-Parameter) und der Funktionsrückgabewert selbst ist die Anzahl der geschriebenen Einträge (alternativ ein Fehlercode, wenn dann die Anzahl der Einträge ein weiterer Parameter ist).

Im Code würde das dann so aussehen:
ausblenden Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
DLLIMPORT int testDoubleArray(int &count, double *buf, int buflen)
{
  // abbrechen, wenn der buffer zu klein ist
  if (buflen < how_many_values_do_i_calculate * sizeof(value_size))
  {
    // hier ist es für den Caller sinnvoll , wenn man in count schreibt, wie viele Werte denn berechnet werden,
    // damit der Caller den buffer neu allokieren kann
    count = how_many_values_do_i_calculate;
    return -1; // Fehler!
  }

  // wenn der Buffer groß genug ist, ist ja alles in Ordnng
  for (count = 0; count < how_many_values_do_i_calculate; count++)
  {
    buf[i] = i/3.0; //nur zum testweisen erzeugen von Doubles
  }
  return 0; // kein Fehler
}
In einem Delphi-Programm hätte diese Funktion folgende Signatur:
ausblenden Delphi-Quelltext
1:
function testDoubleArray(var count: Integer; buf: PDouble; buflen: Integer);					

Aufrüfen könnte ich sie wie folgt:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
var
  buffer: PDouble;
  count: Integer;
  buflen: Integer;
  i: Integer;
begin
  // hiermit erzwinge ich, daß die Funktion fehlschlägt und mir die Anzahl der Einträge zurückgegeben wird
  testDoubleArray(count, nil, 0);
  // in count befindet sich jetzt die Anzahl der Einträge, die die Funktion erzeugen möchte
  // also erzeuge ich einen passenden Buffer
  buflen := GetMem(buffer, sizeof(Double) * count);
  testDoubleArray(count, buffer, sizeof(Double) * count);

  // alle Werte ausgeben
  for i := 0 to count - 1 do
    ShowMessage(FloatToStr((buffer+i)^));

  FreeMem(buffer); // never forget ;-)
end;


Kannst du die Zahl der berechneten Werte unmöglich vorher bestimmen, nimmt man meist zufällig allokierte Buffer, von denen man annimmt, daß sie groß genug sein werden. Sollte sich diese Annahme als falsch herrausstellen, gibt die Funktion einen passenden Fehlerwert zurück und man allokiert einen neuen Buffer, jetzt ein wenig größer, solange bis man endlich alle Werte hat. Ist nicht elegant, aber auf jeden Fall portabel, egal in welcher Sprache deine DLL geschrieben ist und welcher wiederliche Speichermanager benutzt wurde.


P.S.: Ich suche schon seit langem einen Thread, für den es Wert ist, meinen 4000sten Post zu schreiben, und du hast mir einen geliefert. Danke! ;-)

_________________
Your computer is designed to become slower and more unreliable over time, so you have to upgrade. But if you'd like some false hope, I can tell you how to defragment your disk. - Dilbert
shritis Threadstarter
Hält's aus hier
Beiträge: 5



BeitragVerfasst: Mi 24.08.05 12:28 
Na das ist doch mal eine Aussage - vielen vielen Dank. Die Idee mit dem erzwungenen Fehler und doppeltem Aufruf gefällt mir ziemlich gut.

Und herzlichen Glühstrumpf zum 4000. :D

Danke nochmal.

Ciao,
Robert
shritis Threadstarter
Hält's aus hier
Beiträge: 5



BeitragVerfasst: Mi 24.08.05 14:14 
hab jetzt nach langem probieren eine weitere Lösung gefunden (falls es noch andere interessiert :) )

DLL-Code:
ausblenden Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
DLLIMPORT int testDoubleArray(double **arr, int *count)
{
  *count = 10; //whatever will be the needed number of elements
  *arr = (double*)malloc(*count * sizeof(double));
  int i = 0;
  for (i = 0; i < *count; i++)
  {
    (*arr)[i] = i; //just for testing
  }
  return(0);
}

Durch double **arr behält Delphi den "Hauptzeiger" und malloc kann den Speicherbereich auf den *arr zeigt, allokieren.

Delphi-Code:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
var testDoubleArray: function(var arr :PDouble; var size :Integer) :Integer cdecl  {$IFDEF WIN32} stdcall {$ENDIF};

[...]
var
buf :PDouble;
count, i :Integer;
testDoubleArray(buf, count);
//Zugriff auf die einzelnen Elemente dann mit d^ und inc(d)


Einziges Problem ist dann noch die Speicherfreigabe durch die DLL oder den Caller, aber das wird sich auch noch ergeben :)

Ciao,
Robert
tommie-lie
ontopic starontopic starontopic starontopic starontopic starofftopic starofftopic starofftopic star
Beiträge: 4373

Ubuntu 7.10 "Gutsy Gibbon"

BeitragVerfasst: Mi 24.08.05 14:24 
user profile iconshritis hat folgendes geschrieben:
Einziges Problem ist dann noch die Speicherfreigabe durch die DLL oder den Caller, aber das wird sich auch noch ergeben :)
Genau aus diesem Grund sorgt normalerweise der Caller für den Speicher und gibt ihn auch selbst wieder frei. Dann ist es nämlich egal, ob die Speichermanager zusammenspielen oder nicht, wenn hinten ein Pointer rauskommt kann man mit dem alles machen und derjenige, der den Speicher allokiert hat, gibt ihn auch wieder frei.
Einzige Alternative, die mir einfällt, ist das Verwalten aller Speicherbereiche, die für solche Berechnungsergebnisse benötigt werden durch die DLL und das Freigeben über eine Funktion in der DLL (z.B. FreeResultMemory()).
Oder man benutzt nie den Speichermanager des jeweiligen Compilers sondern benutzt die Heap-Funktionen, die die Windows-API bereitstellt, da DLL und EXE im gleichen Prozess laufen sollte das keine Probleme machen (ich würde es dennoch nicht tun ;-)).

_________________
Your computer is designed to become slower and more unreliable over time, so you have to upgrade. But if you'd like some false hope, I can tell you how to defragment your disk. - Dilbert