Zeigertyp von C nach Delphi

[Neutral General]

Hi,

Ich habe sowas hier vorliegen:

Code:

typedef void (__cdecl *PFNFCIFREE)(void *memory);
#define FNFCIFREE(fn) void __cdecl fn(void *memory)

das habe ich bisher so übersetzt:

Delphi-Quellcode:

FNFCIFREE = procedure (memory: Pointer); cdecl;

stimmt das?

Und hieß das, dass folgendes

Code:

typedef void * (__cdecl *PFNFCIALLOC)(ULONG cb);
#define FNFCIALLOC(fn) void * __cdecl fn(ULONG cb)

dann dem entsprechen würde:

Delphi-Quellcode:

FNFCIALLOC = function (cb: ULONG): Pointer; cdecl;

?

Gruß
Neutral General

[sniper_w]

Ich sehe da keinen Fehler.

[Neutral General]

Ok danke mehr wollte ich nicht wissen :)

[Olli]

Nenn mich pingelig, aber es stimmt nicht ganz.

PFNFCIFREE und PFNFCIALLOC sind die Typendeklarationen, wenn du also ein "P" vor den Namen setzt, ist es formal wieder richtig. Das Makro erstellt offenbar die echte Funktionsdeklaration und Prototypen der Implementation. Folglich entspräche folgender Code in Delphi:

Code:

#define FNFCIFREE(fn) void __cdecl fn(void *memory)

FNFCIFREE(FunktionsName)
{
  // Mach was
}

Delphi-Quellcode:

function FunktionsName(cb: ULONG): Pointer; cdecl;
begin
  // Mach was
end;

... dieses Makro ist aber vermutlich für den Anwender der DLL irrelevant, es sei denn es handelt sich um Callbacks. In letzterem Fall mußt du es aber ohnehin händisch machen, weil Delphi ja keinen C-Präprozessor hat :mrgreen:

[Neutral General]

Ich weiß jetzt nicht genau was Callbacks sind aber ich glaube es sind welche. Es sind Procedurentypen die an eine andere Procedure der DLL übergeben werden müssen.

Delphi-Quellcode:

procedure Bla(params: ka);
begin

end;

var cifree: PFNFCIFREE;
begin
  new(cifree);
  cifree^ := Bla;
  DLLProcedure(bla);
end; // so ungefähr^^

[Olli]

Jupp, sieht stark nach Callbacks aus.

Da gibt es aber nicht wirklich einen Unteerschied. Wenn du die Adresse der Funktion

Delphi-Quellcode:

function MeineAllocFunktion(cb: ULONG): Pointer; cdecl; 
begin 
  // Mach was 
end;

... übergeben willst, machste das einfach mit "@MeineAllocFunktion" - die Prototypen müssen halt nur mit dem deklarierten Typ übereinstimmen. Also alles im grünen Bereich, vermute ich mal :zwinker:

Nur warum nicht direkt

Delphi-Quellcode:

var cifree: PFNFCIFREE; 
begin
  cifree := @MeineAllocFunktion;
  DLLProcedure(cifree);
end; // so ungefähr^^

oder

Delphi-Quellcode:

begin 
  DLLProcedure(@MeineAllocFunktion);
end; // so ungefähr^^

???

[Neutral General]

Zitat:

Zitat von Olli

Nur warum nicht direkt

Delphi-Quellcode:

var cifree: PFNFCIFREE; 
begin
  cifree := @MeineAllocFunktion;
  DLLProcedure(cifree);
end; // so ungefähr^^

oder

Delphi-Quellcode:

begin 
  DLLProcedure(@MeineAllocFunktion);
end; // so ungefähr^^

???

Wieso einfach wenns auch kompliziert geht ? ;) :mrgreen: :wall:

[Olli]

Zitat:

Zitat von Neutral General

Wieso einfach wenns auch kompliziert geht ? ;) :mrgreen: :wall:

:mrgreen:

Übrigens ist das in C noch einfacher, da gibt der Name der Funktion die Adresse zurück und sobald Parameter (oder eben keine) in runden Klammern übergeben werden, handelt es sich um einen Funktionsaufruf. So unterscheidet das eben die Sprache C, obwohl ich den Ansatz in Delphi sympathischer finde (weil expliziter). Aber man kann nicht alles haben :zwinker:

[Robert Marquardt]

Code:

typedef void * (__cdecl *PFNFCIALLOC)(ULONG cb);
#define FNFCIALLOC(fn) void * __cdecl fn(ULONG cb)

Das erste ist eine Typdeklaration fuer einen Funktionstyp.

Delphi-Quellcode:

type
  PFNFCIALLOC = function(cb: ULONG): Pointer; cdecl;

FNFCIALLOC hingegen ist ein Makro mit dem man passende Funktionen deklariert oder definiert.

Code:

// Prototyp deklarieren
FNFCIALLOC(testfunktion); 

FNFCIALLOC(testfunktion)
 {
  return NULL;
 }

Das resultiert nach Bearbeitung durch den Preprocessor in:

Code:

// Prototyp deklarieren
void * __cdecl testfunktion(ULONG cb); 

void * __cdecl testfunktion(ULONG cb)
 {
  return NULL;
 }