Ich hab jetzt endlich mal was mit DLLs gemacht, allerdings in PureBasic, aber das macht ja nichts denn DLLs kann man ja auch verwänden um in einer Sprache etwas zu schreiben und die DLL dann in einer anderen Sprache wieder zu verwänden

So habe ich das auch mit PureBasic und Blitz3D gemacht, in PB geschrieben und in B3D die DLL genutzt.

Das möchte ich jetzt auch mal mit C++ machen, also so zu sagen als Notlösung um Dinge, die ich in C++ noch nicht kann aber dafür in anderen Sprachen, durch DLLs zu nutzen.
Aber ich weiß nicht welche Bibliothek ich dafür laden muss und wie die Funktionen heißen um eine DLL Funktion auf zu rufen.

Kann mir da vielleicht jemand einen kleinen BeispielCode in`s Forum tippen?
Sollte doch nicht so lang sein, oder?!

Gruß LukasBanana

Erstmal zur Defninition der Funktionen, die in der DLL ausgelagert werden sollen. Die folgende Datei wird dann zur DLL kompiliert:

dll.cpp:

#include "dll.h"
#include <windows.h>
#include <iostream>

void hallo()
{
  std::cout<<"HALLO AUS DER DLL !!!!";
}

BOOL APIENTRY DllMain (HINSTANCE hInst     /* Library instance handle. */ ,
                       DWORD reason        /* Reason this function is being called. */ ,
                       LPVOID reserved     /* Not used. */ )
{
    switch (reason)
    {
      case DLL_PROCESS_ATTACH:
        break;

      case DLL_PROCESS_DETACH:
        break;

      case DLL_THREAD_ATTACH:
        break;

      case DLL_THREAD_DETACH:
        break;
    }

    /* Returns TRUE on success, FALSE on failure */
    return TRUE;
}

Nun die dazugehörige Headerdatei (benötigt man zur Kompilierung der DLL:)

#ifndef _DLL_H_
#define _DLL_H_

#if BUILDING_DLL
# define DLLIMPORT __declspec (dllexport)
#else /* Not BUILDING_DLL */
# define DLLIMPORT __declspec (dllimport)
#endif /* Not BUILDING_DLL */

extern "C"
{
    DLLIMPORT void hallo ();
}

#endif

Nachdem du nun die DLL erfolgreich kompilert hast, kannst du sie nun wiefolgt anwenden;

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

using namespace std;

typedef void (*ptrhallo)();

int main ()
{

     ptrhallo MeineDllFunktion;
     HINSTANCE hLib;

     //Holt mir das Handle auf die DLL
     hLib = LoadLibrary("Sleep.dll");
     BOOL status;

     if (hLib)
     {
          MeineDllFunktion = (ptrhallo) GetProcAddress(hLib, "hallo");
          MeineDllFunktion ();
     }
     else
        cout << "Fehler: Konnte die Funktion nicht aufrufen" <<"\n";

     status = FreeLibrary(hLib); //Löst das Handle wieder
     getchar ();
     return 0;
}

Hoffe das hilft weiter MfG mikey.

Wie kann ich mehrere Klassen verteilt auf jeweils eine 1 Header und eine Sourcedatei nun zu einer dll zusammenfassen?

Das mit dem Codebeispiel ist dabei sehr nützlich.

chrische

MfG SideWinder

SideWinder schrieb:

Du kannst nach oben beschriebenen Schema beliebig viele Dateien zu einer DLL zusammenfassen. Nur die DllMain benötigst du nur in einem einzigen Sourcefile deines DLL-Projekts.

MfG SideWinder

Genau daran bin ich immer gescheitert. Das es geht, weiß ich ja, nur bekomme ich es nicht hin.

chrische

MfG SideWinder

MfG SideWinder

Die DLL enthält bestimmt eine Export-Funktion namens "_hallo" oder noch abgefahrener.

Probier mal die Funktion als CALLBACK zu deklarieren :

extern "C"
{
//    DLLIMPORT void hallo ();
    DLLIMPORT void CALLBACK hallo ();
}

// void hallo()
void CALLBACK hallo()
{
  std::cout<<"HALLO AUS DER DLL !!!!";
}

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Hallo

Wie kann ich mehrere Klassen verteilt auf jeweils eine 1 Header und eine Sourcedatei nun zu einer dll zusammenfassen?

Das mit dem Codebeispiel ist dabei sehr nützlich.

chrische

Du benutzt einfach bei der Deklaration der Klasse das Schlüsselwort __declspec(dllexport), Beispiel:
CExample.hpp:

class __declspec(dllexport) CExample
{
   private:
     int m_iValue;
     // usw...
   public:
     CExample(void);
     ~CExample(void);

     int GetValue(void) const;
     void SetValue(int iNew);
     // usw...
}

CExample.cpp:

CExample::CExample(void)
{
   m_iValue = 0;
   // ...
}

CExample::~CExample(void)
{
   // ...
}

int CExample::GetValue(void) const
{
   // ...
   return (m_iValue);
}

void CExample::SetValue(int iNew)
{
   m_iValue = iNew;
   // ...
}

Die Dateien einfach mit ins DLL-Projekt, compilieren und gut ist .

PS: Hier darf natürlich NICHT das Schlüsselwort extern "C" verwendet werden!

DLLMain braucht man nicht unbedingt, nur wenn man explizit auf das Laden, Entladen der DLL reagieren möchte.

Einfaches Beispiel für eine DLL die eine kleine Funktion exportiert:

extern "C" __declspec(dllexport) void test()
{
MessageBox(NULL, "Hello World", "", MB_OK);
}

Oder hab ich jetzt auf die falsche Frage reagiert bzw. war das gar nicht die Frage?!

PS: obiges Beispiel gilt nur für MSVS, keine Ahnung wie die Syntax für andere Compiler lautet.

Die DLL kann entweder statisch oder dynamisch geladen werden. Ich werde jetzt erstmal auf die dynamische Variante eingehen:

irgendwo in der main:

HMODULE hDLL = LoadLibrary("Dllname.dll");
void (*pfunc)() = (void (*)()) GetProcAddress(hDLL, "test");
pfunc();

Damit wird dann die test() Funktion in der DLL aufgerufen. Achtung, es wurde keine Fehlerüberprüfung durchgeführt...
Wichtig ist nur, dass die DLL auch auffindbar ist Sonst liefert LoadLibrary() NULL.

Logisch soweit?

Hat funktioniert und war super leicht!

Gruß LukasBanana

Da empfiehlt sich auch ein typedef zu verwenden. Macht die ganze Sache übersichtlicher .

Vielleicht so?

typedef extern "C" __declspec(dllexport) DLLexport;

Gruß LukasBanana

Also

#define DLLEXPORT __declspec(dllexport)

Was Codefinder vermutlich meint, sind typedefs für die Funktionspointer.
z.B.

typedef void (*voidfunc)();

Dann kannst Du schreiben:

voidfunc pfunc = (voidfunc) GetProcAddress(...)

macht die Sache wesentlich übersichtlicher wenn der Prototyp länger wird. Oder man es oft benutzt :-).

typedef void (*PFUNCTION)(void); // 'PFUNCTION' wird jetzt wie ein Typ behandelt, also bspw. wie int
HMODULE hDLL = LoadLibrary(TEXT("Dllname.dll")); // DLL laden
if(hDLL != NULL) // Prüfen, ob DLL erfolgreich geladen werden konnte
{
   // Funktionszeiger-Variable anlegen und Adresse der Funktion in der DLL ermitteln:
   PFUNCTION pFunction = reinterpret_cast<PFUNCTION>(GetProcAddress(hDLL, "test"));
   if(pFunction != NULL) // Wichtig: Konnte die Adresse der Funktion erfolgreich ermittelt werden ? Falls nein, darf die Funktion nicht aufgerufen werden, sonst würde es hier eine Access-Violation geben!
      pFunction(); // Erfolgreich ermittelt, also aufrufen!
}

/* ... */
typedef (void (*)()) voidfunc;
typedef (int (*)()) intfunc;
typedef (float (*)()) floatfunc;
/* ... */
void (*MyFunc)() = voidfunc GetProcAddress(hDLL, "MyDLLFunction");

Gruß LukasBanana