dll import

Mah

Servuus,
wir versuchen gerade verzweifelt mit dlls umzugehen. Wir haben jetzt zwar erfolgreich eine dll-Datei kompiliert und koennen auch die in ihr definierten Funktionen aufrufen. Toll, wir koennen jetzt aber nicht aus der dll heraus eine Funktion aufrufen, die Teil des Hauptprogramms ist.

Wir benötigen dringendst Hilfe!!!

Vielen Dank und viele Grüße,
Robert.

WebFritzi

Gebt der DLL doch den Funktionspointer mit.

Mah

Sorry, aber ich versteh nur Bahnhof;) Nein, ganz so schlimm jetzt nicht aber könntest du das ein wenig genauer beschreiben bzw. einen Code-Schnippsel angeben??

Danke,
Robert.

WebFritzi

Naja, sagen wir, ihr habt in eurem Hauptproggi eine Funktion

int foo(float fl)
{
  //...
}

Dann definiert ihr in der DLL einen Funktionspointer-Typen, definiert eine globale Variable davon und setzt diese in einer Extra-Funktion:

typedef int (*FOOPOINTER)(float);

FOOPOINTER foo = NULL;

void SetFooPointer(FOOPOINTER& f)
{
   foo = f;
}

Im Hauptproggi ruft ihr dann nach dem Laden der DLL (mit LoadLibrary) die Funktion SetFooPointer() auf mit dem Namen eurer Funtion im Hauptprogramm. Dann könnt ihr in der DLL mit foo arbeiten. Und vergesst nicht, bei Beenden eures Proggis SetFooPointer(NULL) aufzurufen (und natürlich FreeLibrary()).

[ Dieser Beitrag wurde am 19.01.2003 um 01:32 Uhr von WebFritzi editiert. ]

Mah

hab dann in meiner load_plugin funktion
folgendes:

void load_plugin () {
cfung hello_world;
cfunc SetFooPointer;
[..]
hello_world = (cfunc)GetProcAddress((HMODULE)hLib, "hello_world");
SetFooPointer = (cfunc)GetProcAddress((HMODULE)hLib, "SetFooPointer");
[..]
SetFooPointer (Function);
hello_world ();
[..]
}

Jetzt will der Compiler aber den Funktionsnamen "Function" als Argument an SetFooPointer nicht akzeptieren ?? Klar, er weiss ja auch nicht dass die Funktion überhaupt Argumente annehmen kann; aber wie mach ich ihm das "klar"??

Danke, viele Grüße und ne schöne Nacht noch,
Robert.

WebFritzi

Jetzt will der Compiler aber den Funktionsnamen "Function" als Argument an SetFooPointer nicht akzeptieren ??

Ja, er muss doch irgendeinen Fehler ausspucken. Wenn du den hier nicht nennst, kann dir auch nicht geholfen werden. Vielleicht hilft es dir, denselben typedef aus der DLL auch noch in dein Hauptproggi mit reinzunehmen und dann Function beim Aufruf von SetFooPointer() nach FOOPOINTER zu casten, also

SetFooPointer((FOOPOINTER)Function);

Mah

Sorry, ich dachte dass sei klar:

Compiler message: Too many arguments to function
- bezieht sich auf SetFooPointer-Aufruf im Hauptprog nach laden der dll und der Funktion

Auszug aus void load_plugin ()

SetFooPointer = (cfunc)GetProcAddress((HMODULE)hLib, "SetFooPointer");
[..]
SetFooPointer (Function);

Die SetFooPointer ist ja aber mit Argumenten in der dll deklariert worden (SetFooPointer (FOOPOINTER &f)), dass weiss aber das Hauptprog zu dem Zeitpunkt nicht; muss es ja irgendwie in der hier ersten angegebenen Codezeile klarmachen...

Grüße,
Robert.

WebFritzi

cfunc

Was ist das? Wie hast du das deklariert?

Mah

Deklaration von cfunc:

typedef void (WINAPI*cfunc)();

cfunc SetFooPointer;

Das hab ich so in mehreren Samples/Tuts gesehen, und funcktioniert auch, zumindest für dll-Funtkionen ohne Argumente

Grüße,
Robert.

WebFritzi

Du scheinst dich mit Funktionspointern nicht so auszukennen. Du willst eine Funktion in deiner DLL bekanntmachen, die ein void nimmt und ein void ausspuckt. Dann deklariere FOOPOINTER in der DLL auch so:

typedef void (WINAPI *FOOPOINTER)(void);

Dann wird es laufen.

Mah

ich hab hier jetzt mal den Code (bzw. Ausschnitte)... Könnte mir bitte jemand weiter helfen... siehe vorherige posts.

--- main.cpp ----

#include <stdlib.h>
#include <windows.h>
#include <iostream.h>
#include <conio.h>
#include <stdio.h>

#define MAXMODULE 50

void fuckoff ();

char module[MAXMODULE];
typedef void (WINAPI*cfunc)();

cfunc hello_world;
FOOPOINTER SetFooPointer;

void load_plugin () {
   HINSTANCE hLib = LoadLibrary("lib.dll");
   if(hLib == NULL) {
      //g_print ("Unable to load library!\n");
      getch();
      //return 0;
   }

    GetModuleFileName((HMODULE)hLib, (LPTSTR)module, MAXMODULE);
   //g_print ("Library loaded: ");
   hello_world = (cfunc)GetProcAddress((HMODULE)hLib, "hello_world");
   SetFooPointer = (cfunc)GetProcAddress((HMODULE)hLib, "SetFooPointer");
   if((hello_world == NULL) | (SetFooPointer == NULL)) {
      //g_print ("Unable to load function");
      FreeLibrary((HMODULE)hLib);
      //return 0;
   }

   SetFooPointer (func_in_main);
    hello_world ();

     FreeLibrary((HMODULE)hLib);
   getch();
}

int WINAPI
WinMain (HINSTANCE hThisInstance,
         HINSTANCE hPrevInstance,
         LPSTR lpszArgument,
         int nFunsterStil)
{         
[...]
load_plugin ();
return 0;
}

void func_in_main () {
[...]
}

----------------

----lib.cpp----

#include <iostream.h>
#include <stdio.h>
#include <windows.h>

typedef void (WINAPI *FOOPOINTER)(void);
FOOPOINTER fuckoff = NULL;

extern "C" __declspec(dllexport) void hello_world();

#include "lib.h"

void SetFooPointer (FOOPOINTER & f) {
   func_in_main = f;
}

extern "C" __declspec(dllexport) void hello_world () {
[...]
func_in_main ();
}

Grüße, Robert.

Edit: Bitte benutze Codetags.

[ Dieser Beitrag wurde am 24.01.2003 um 19:24 Uhr von cd9000 editiert. ]

Christoph

Also aus dem was du gepostet hast werde ich nicht so recht schlau. Anscheinend weißt du selbst nicht so genau was du da eigentlich machst.

void SetFooPointer (FOOPOINTER & f) {
   func_in_main = f;
}

Da weist du der nicht deklarierten Variable func_in_main den Wert von f zu (warum auch immer du da call by reference nimmst).

Du solltest FOOPOINTER auch in der Exe bekannt machen. In der Lib ist das fehl am Platze; da wird kein FOOPOINTER gebraucht, eher cfunc.

SetFooPointer = (cfunc)GetProcAddress((HMODULE)hLib, "SetFooPointer");

Du weißt doch noch welche Signatur SetFooPointer in der lib hat? Genau, es hat einen Parameter, der übrigens cfunc und nicht FOOPOINTER sein sollte.
Warum castest du dann nach cfunc und nicht nach FOOPOINTER?

extern "C" __declspec(dllexport) void hello_world () {
    func_in_main ();
}

func_in_main ist der lib nicht bekannt... Benutz den Funktionzeiger!

extern "C" __declspec(dllexport) void hello_world () {
    fuckoff();
}

Hatte ich schon erwähnt, dass fuckoff vom Typ cfunc sein muss?

Und FOOPOINTER sollte so aussehen:

typedef void (WINAPI * FOOPOINTER)(cfunc);

Ist nicht böse gemeint, aber ich rate dir, dass du erstmal richtig C++ lernst. Besonders (Funktions-)Zeiger solltest du wiederholen, bevor du sowas in DLLs benutzen willst.

btw:
Warum um alles in der Welt bindest du <iostream.h>, <conio.h> und <stdio.h> in ein WinAPI-Programm ein? Das ist nicht wirklich sinnvoll, zumal du keine einzige Funktion daraus benutzt.

2nd btw:
Du darfst ruhig bessere Namen wählen. FOOPOINTER und cfunc sind bestimmt nur Beispiele, die man so nicht in richtigen Programmen einsetzen sollte.

WebFritzi

*lol* Ich dachte, du wolltest eine DLL proggen. Wo ist denn der EntryPoint?

hier!!!

WebFritzi

Du kleiner I-d-i-o-t!

Christoph

Man kann DLLMain auch weglassen.

Kompiliert wirds trotzdem. Ich vermute es läuft sogar (ich hab nur kompilieren getestet). Logischerweise nur solange nicht irgendwelche Sachen initialisiert werden müssen.

siehste WebFritzi :p

Christoph

Bitte lasst diesen Thread nicht in einen Flamewar ausarten, ok?

Flamewar? Nö!

Mah

Servuus,
ich muss jetzt mal ein großes Dankeschön an WebFriti und cd aussprechen.
Eure beiden Beiträge zusammen haben mir viel gebracht. Ich denke ich hab jetzt auch ne Menge dazugelernt:)

Viele Grüße,
Robert.