DLL-Funktionen aus einer DLL aufrufen

tach!

ich möchte funktionen einer DLL von einer DLL aus aufrufen.
jetzt möchte ich gerne zwei sachen wissen. ob die haupt DLL richtig ist und wie ich die bereits vorhandene DLL erweitern muss, damit ich die funktionen aus der haupt DLL aufrufen kann.

Haupt DLL, die funktionen exportiert

extern "C++" __declspec(dllexport) void Render(int, const char*, bool, bool, bool);

void Render(int Number, const char *Name, bool GFX, bool Text, bool Animal)
{
    //DoSomething....
}

int WINAPI DllEntryPoint(HINSTANCE hinst, DWORD ul_reason_for_call, unsigned long reason, void* lpReserved)
{
	switch (ul_reason_for_call)
	{
		case DLL_PROCESS_ATTACH:
		case DLL_THREAD_ATTACH:
		case DLL_THREAD_DETACH:
		case DLL_PROCESS_DETACH:
		break;
    }
	return 1;
}

Ist das korrekt so?

Existierende DLL - Aufruf der funktion von der Haupt-DLL
- Was muss ich hier nun alles machen damit ich die funktion von der haupt DLL aufrufen kann? leider geht die suchfunktion des boards nicht

Achja, dynamisch (LoadLibrary)

Existierende DLL - Aufruf der funktion von der Haupt-DLL
- So hab ich das versucht, aber das geht nicht? hm

__declspec(dllimport) void *Render(int, const char*, bool, bool, bool);

void AnyFunction()
{
	HMODULE hMod = LoadLibrary("engine.dll");
	if(hMod)
	{
		void *Render = GetProcAddress(hMod, "Render");
		if(html_Score)
		{
        	Render(3532,"gizmo",true,true,false)
            FreeLibrary(hMod);
		}
	}
}

Soory, so:

__declspec(dllimport) void *Render(int, const char*, bool, bool, bool); 

void AnyFunction() 
{ 
    HMODULE hMod = LoadLibrary("engine.dll"); 
    if(hMod) 
    { 
        void *Render = GetProcAddress(hMod, "Render"); 
        if(Render) 
        { 
            Render(3532,"gizmo",true,true,false); 
            FreeLibrary(hMod); 
        } 
    } 
}

hey moment mal. statisch ist das ja ganz einfacher und besser!!?
hab ich das folgende richtig verstanden?

ALLES WAS BENÖTIGT WIRD UM DLL-FUNKTIONEN ZU NUTZEN (STATISCH)
DLL

extern "C++" __declspec(dllexport) void DIE_FUNKTION();

void DIE_FUNKTION()
{
    //Lets rock!
}

EXE
DIE LIB VON DER EBEN GESCHRIEBENEN DLL DEM PROJEKT HINZUFÜGEN

extern "C++" __declspec(dllexport) void DIE_FUNKTION();

int main()
{
    DIE_FUNKTION();
}

Das war es!? Stimmt das so? Ist ja cool.
kann mir jemand vor/nachteile von dynamisch/statisch nennen?

Vorteil von statisch: schneller in der Ausführung, sicherer (weniger Fehleranfäällig)

Vorteile von dynamisch: .exe ist kleiner.

Mfg.

Deadlef

Bin ja nicht ganz sicher, DLLs habe ich bisher nur mal am Rande angefasst, aber muss es nicht in der Executable

extern "C++" __declspec(dllimport) void DIE_FUNKTION();

heissen?!?

@Tolga: Moment. da gibt es meiner meinung nach zwei arten von statisch. Wenn die DLL statisch erstellt wurde, ist somit die ganze lib eigentlich die DLL? wenn die DLL aber dynamisch erstellt wurde, ist die Lib dazu sehr klein, da es nur die exportierten funktionsnamen enthält, die DLL wird also extern noch benötigt (ist nicht im eigentlichen projekt mitgelinkt).

@Deadlef: Bin ich mir auch nicht sicher. jedenfalls funktioniert es wenn bei beiden dllexport steht.

dietermoor schrieb:

@Tolga: Moment. da gibt es meiner meinung nach zwei arten von statisch. Wenn die DLL statisch erstellt wurde, ist somit die ganze lib eigentlich die DLL? wenn die DLL aber dynamisch erstellt wurde, ist die Lib dazu sehr klein, da es nur die exportierten funktionsnamen enthält, die DLL wird also extern noch benötigt (ist nicht im eigentlichen projekt mitgelinkt).

Und in welcher Relation steht das zu dem was ich sagte?
Was hast du verbessert?

Mfg.