Invalid Pointer Problem in DLL

[iphi]

Hallo,

meine DLL soll ein dynamisches Array, welches das aufrufende Progamm definiert, befüllen.

Hier mein Minimalcode:

Delphi-Quellcode:

... im aufrufenden Programm
var f: TFloatArray;
procedure TForm1.Button1Click(Sender: TObject);
begin
SetLength(f,1);
VIDLL_DoIt(f);
end;

... in der DLL
var Freq: TFloatArray;
procedure _DoIt(Frq: TFloatArray); export; cdecl;
begin
Freq:=Frq;
end;

Wenn ich den Knopf das erste mal drücke, gibt es keine Probleme. Im Debugger sehe ich auch in der DLL das korrekt übergebene Array (ich weiß, es wird nur die Adresse übergeben). Beim zweiten Mal kommt "Invalid Pointer Operation", aber nur wenn die Länge des übergebenen Arrays nicht Länge Null hat. Woran liegt das?
Das ganze läuft oder besser läuft nicht in Delphi6.

P.S.
Wenn ich in der DLL die Arrays als Pointer statt als TFloatArray deklariere, tritt das Problem nicht auf, also so:

Delphi-Quellcode:

... im aufrufenden Programm
var f: TFloatArray;
procedure TForm1.Button1Click(Sender: TObject);
begin
SetLength(f,1);
VIDLL_DoIt(f);
end;

... in der DLL
var Freq: Pointer;
procedure _DoIt(Frq: Pointer); export; cdecl;
begin
Freq:=Frq;
end;

[hoika]

Hallo,

Was macht dein Programm mit dem Array?
Du darfst nicht davon ausgehen, dass der Pointer,
den du der DLL übergibst, immer gleich ist.
Ein Zwischenspeichern in der DLL solltest du
also gleich sein lassen.

Heiko

[Bummi]

Die Speicherverwaltung von dynamischen Arrays entspricht der von Strings, welche ja bekanntermaßen nicht (ohne Sharemem) übergeben werden dürfen.
Programm und DLL allozieren getrennte Speicherbereiche für die Arrays (und verwalten deren Freigabe) und Du gibst in Deinem Beispiel nur die Zeiger dafür hin und her.
Sauber wäre es einen Zeiger auf das erste Element, sowie die Größe des Arrays zu übergeben und in der DLL die Daten an diese Zieladresse zu schreiben.

[iphi]

Zitat:

Du darfst nicht davon ausgehen, dass der Pointer,
den du der DLL übergibst, immer gleich ist.

Tue ich auch nicht, siehe

http://www.delphipraxis.net/173129-f...anagement.html

Zitat:

Die Speicherverwaltung von dynamischen Arrays entspricht der von Strings, welche ja bekanntermaßen nicht (ohne Sharemem) übergeben werden dürfen.

Was genau macht ShareMem eigentlich.
Ich übergebe doch nur einen Zeiger auf eine gültige Datenstruktur und greife dann auf diese Speicherzellen zu. Wozu brauche ich da ShareMem?
Brauche ich dann ShareMem auch für jede Zeigervariable?
Das ganze soll irgendwann auch mit einer z.B. in VisualC++ erzeugten DLL funktionieren. Gibts da auch ShareMem?

So geht das ganze jedenfalls ohne ShareMem korrekt:

Delphi-Quellcode:

... in DLL
var Freq: Pointer;
procedure _DoIt(Frq: Pointer); export; cdecl;
begin
Freq:=Frq;
writeln(TFloatArray(Freq)[0]);
writeln(length(TFloatArray(Freq)));
end;

P.S. Ich habe über ShareMem nachgelesen:
http://delphi.about.com/od/objectpas.../aa103003b.htm

Ich verstehe mein Problem aber immer noch nicht. Ich übergebe doch eine absolute Speicheradresse im RAM des PC. Und da finde ich auch meine Daten. Oder sehe ich das falsch?

[Bummi]

gerade wenn es mit etwas anderem als Delphi funktionieren soll wirst Du mit dem Zeiger auf TFloatArray nichts mehr anfangen können.

Delphi-Quellcode:

type
TFloatArray=Array of Double;
var
 F:TFloatArray;
 S:String;
procedure TForm1.Button1Click(Sender: TObject);
begin
  SetLength(f,10);
  SetLength(s,10);

  Showmessage(Format('Addr F %d Addr F[0] %d'#13#10'Addr S %d Addr S[1] %d'
                    ,[Integer(@F),Integer(@F[0]),Integer(@S),Integer(@S[1])])

                      );
end;

[iphi]

Danke für den kleinen Code. Habs verstanden. Das dynamische Array ist also offenbar ein Zeiger auf einen Record bestehend aus einem Zeiger auf die Daten und einer Größenangabe, oder?

Bleibt meine eigentliche Frage:
Sind Delphipointer absolute Adressen oder relative Andressen bezüglich irgendeines Bezugsrahmens (Heap, Stack...)?

D.h. wenn ich einer Visual C++ DLL einen Zeiger aus einem Delphi-Hauptprogramm übergebe, findet die DLL dann immer sicher die Daten auch ohne ShareMem?

P.S. Absolute Adressen können es nicht sein, sonst könnte ja jede Anwendung auf die Daten jeder anderen Anwendung zugreifen.

[Bummi]

Der Zeiger aus den eigentliche Buffer, in dem Beispiel @Frequ[0] kann bedenkenlos übergeben werden, viele Windows API - Aufrufe bekommen Zeiger auf Variablen und Zielbuffer übergeben.

[iphi]

Zitat:

Der Zeiger aus den eigentliche Buffer, in dem Beispiel @Frequ[0] kann bedenkenlos übergeben werden

Dann kann ich aber auch einfach Freq übergeben, weil Pointer(Freq) und @Freq[0] sind identisch, habs gerade ausprobiert.
D.h.:

Delphi-Quellcode:

var Freq: array of double;
function funct(f: pointer):TIrgendwas;
...
funct(Freq);
... ist identisch mit
funct(pointer(Freq));
... ist identisch mit
funct(@Freq[0]);

Und Delphi übergibt offensichtlich bei einem dynamischen Array im Funktionsargument den Zeiger auf die Daten.
Sonst würde mein Beispiel nicht funktionieren.
Eine C++ Funktion kann so einfach mit einem Typecast auf ein Array darauf zugreifen.

[Bummi]

@iphi
Du hast Recht, ich war völlig auf dem Holzweg

[Furtbichler]

Ähem, nur der Vollständigkeit halber: Die Aufrufkonvention ist bei beiden (Host und DLL) identisch?