Ich habe einen Errorhandler, der einfach einen Eintrag in eine Datei schreibt (natürlich macht er wesentlich mehr, aber das ist für das Problem nicht wichtig). Dieser ist so angelegt, daß ich eine globale Instanz davon anlege und den Klassen, die einen Error ausgeben sollen, einfach einen Pointer auf diese Instanz gebe, womit sie die entsprechende Funktion selber aufrufen. Soweit sogut.
Nun will ich eine der Klassen in eine DLL auslagern. Das Problem ist aber: Wie konstruiere ich die Aufrufe an den Errorhandler, den die DLL gar nicht kennen kann bzw nicht kennen soll. Den Errorhandler in die DLL hinein zu compilieren, ist das ganz und gar nicht Sinn der Sache.
Meine Idee war nun, das mit einem Callback zu machen, das gelingt mir aber nichtmal soweit, um es zum compilieren zu bringen. Wie müßte das aussehen?

Die bisherige Konstruktion sieht zB so aus (ohne DLL):

class CErrorHandler {
...
    void GenerateError(int i_ErrID, std::string str_ErrText);
...
};

class CTest
{
...
    CTest(CErrorHandler *pErrHdl=NULL) { pIntErrHdl = pErrHdl; };
    void TestFunction() {
        ...
        if(pIntErrHdl)
        {
            pErr->GenerateError(12, "File Access Error");
        }
        ...
    };
...
};

CErrorHanlder mErrhdl;
CTest mTest(&mErrHdl);
mTest.TestFunction();

Wie konstruiere ich die Aufrufe an den Errorhandler, den die DLL gar nicht kennen kann bzw nicht kennen soll.

Den ersten Teil des Satzes verstehe ich nicht. Ist das Problem den Error Handler in der DLL zu nutzen oder ihn an die DLL zu uebergeben?

Fuer letzteres einfach eine Funktion SetErrorHandler in der DLL einfuheren, die den Error Handler an die DLL uebergibt.

Fuer ersteres sehe ich zwei Moeglichkeiten (wenn er nicht in der DLL einkompiliert werden soll):

1. Error Handler inline im Header definieren
2. Polymorphie: (abstrakte) Basisklasse fuer den Error Handler und der eigentliche Error Handler ist dann nur eine Instanz einer abgeleiteten Klasse.

in allen Faellen muss auf jeden Fall natuerlich der Header (im zweiten Fall der der Basisklasse) in der DLL bekannt sein.

CTest((void*) pErrHdl);

und rufe die Funktion mit

CTest myTest(&mErrorHandler);

das ganze auf.
Das funktioniert ja auch, nur weiß ich nicht, wie ich jetzt von diesem void ptr heraus den Aufruf der ErrorHandler Funktionen gestalten soll. Wenn ich

CErrorHandler *pErr = (CErrorHandler*)pErrHdl;
pErr->GenerateError(12, "File Access Error");

mache, dann kompiliert das zwar, linkt aber nicht, weil GenerateError nicht gefunden wird, was auch stimmt, weil der Errorhandler eben nicht mitsamt seinem Code Teil der DLL werden soll.
Ich gebe der DLL also einen Pointer auf eine Funktion. Wie kann ich nun diese Funktion aufrufen, wenn nur deren Definition bekannt ist?

Wie kann ich nun diese Funktion aufrufen, wenn nur deren Definition bekannt ist?

Wie ich das verstehe ist nur die Deklaration bekannt, also die Header in der sich Deine Errorhandler-Klasse befindet - Definition wäre die Implementierung der Methoden an sich, also das, was in den .cpp-Dateien steht. Nur am Rande...

...zu Deinem Problem:

Vielleicht gibt's jetzt zwar einfachere Lösungen, aber mir fallen da momentan nur zwei ein:

1. Du machst Deinen Error-Handler und seine Methoden inline. Allerdings würdest Du das vermutlich nicht wollen, weil der Code dann mit in die DLL compiled wird.

2. Nutze Polymorphie. Mein Ansatz hier wäre der, dass Du Deinen Error-Handler zunächst in eine weitere DLL auslagerst und ihm eine "abstrakte" Basisklasse zugrunde legst. Kurz umrissen:

Zum Beispiel 'errorhandler_base.h':

class CErrorHandler_Base {
...
    virtual void GenerateError(int i_ErrID, std::string str_ErrText) = 0;
    virtual ~CErrorHandler();
...
};

Falls Du Dich damit noch nicht so auskennst, das ist nun eine "abstrakte" Basisklasse. Merkmale sind das virtual vor der Methode, sowie ZUSÄTZLICH das = 0 am Ende. Dadurch wird die Methode zu einer Pure Virtual Method und hat den Sinn, das alle Klassen, die von der hier erben, für die endgültige Implementierung der Methode zuständig sind. Wird dies nicht gemacht, wirft der Compiler einen Fehler. Die "abstrakte" Klasse an sich darf die Methode nicht selbst definieren und man kann somit auch kein Objekt von ihr anlegen. Man verwendet diese Art von Basisklasse als Schnittstelle, da garantiert wird, dass gewisse Methoden zur Verfügung stehen MÜSSEN.

In Deinem jetzigen Error-Handler machst Du jetzt nichts anderes, als von dieser Basisklasse zu erben:

Dein jetziger Error-Handler:

class CErrorHandler : public CErrorHandler_Base {
...

Den gesamten Handler lagerst Du jetzt in eine DLL aus. Aber wie ist Dein Problem jetzt gelöst? Es ist trotzdem nur noch die DEKLARATION der Klasse bekannt, wie soll der Linker seine Referenzen nun finden? Ganz einfach: Deiner CTest übergibst Du statt einem void* nun einen Pointer auf CErrorHandler_Base, also auf die vorher erstellte "abstrakte" Basisklasse.

Was jetzt noch fehlt ist eine sogenannte "Factory"-Funktion. Sie hat den einzigen Sinn und Zweck, ein Objekt von Deinem Error-Handler anzulegen und einen Zeiger darauf zurückzuliefern. Aber in welches Modul gehört diese "Factory"-Funktion?! In Dein Hauptprogramm? In Deine DLL, oder in die DLL mit Deinem Error-Handler? Logischerweise in letztere, weil sich da "der Code Deiner Methoden befindet". Diese besagte Funktion ist äußerst banal:

Factory-Function:

CErrorHandler* getHandler(void) {
   static CErrorHandler instance;
   return &instance;
   }

Folgende Anmerkungen zu dieser Sache hier: Falls Du ganz gut aufgepasst hast, und ich es Dir gut erklärt habe, spätestens aber jetzt müsste Dir auffallen, dass wir in der Funktion einen Pointer auf CErrorHandler zurückgeben, Dein CTest-Konstruktor aber CErrorHandler_Base erwartet - und das ist Polymorphie und ist durch die Pure Virtual Method möglich, die als Schnittstelle dient. Bin leider kein guter Lehrer, also les' Dich besser woanders ein, klappt bestimmt besser

Jeeeedenfalls kannst Du, sobald Du die Error-Handler-DLL in Deine andere DLL einbindest, über getHandler() Deinen Error-Handler bekommen.

Joa, das war jetzt recht schnell hier reingestampft und ich hoffe das funktioniert auch alles so, bzw. löst Dein Problem... Aber vermutlich ist die Lösung etwas umständlich. Ich entschuldige mich bei jedem der sich jetzt die Stirn wegen mir einhämmert :p

EDIT: Hihi, ich sehe gerade, DeSoVoDaMu hat das ja schon weiter oben vorgeschlagen, ich Hammel

Wie ich das verstehe ist nur die Deklaration bekannt, also die Header in der sich Deine Errorhandler-Klasse befindet - Definition wäre die Implementierung der Methoden an sich, also das, was in den .cpp-Dateien steht. Nur am Rande...

Danke, verwechsle ich immer

Ansonsten, wenn ich das richtig verstehe, ist der DLL (mit CTest) der Code des ErrorHandler ja aber doch wieder bekannt (über die vorgeschlagene ErrorHandler DLL). Damit bräuchte man ja gar keine zusätzliche Base Klasse, sondern könnte wieder direkt CErrorHandler benutzen. Das ist zwar schonmal ein Teil, aber ich will ja letztendlich erreichen, daß die End-Applikation selber das Errorhandling zur Verfügung stellen kann und sich dabei lediglich an definierte Interfaces zu halten hat.

Was mir jetzt nicht so ganz klar ist: Ich hab deinen Ansatz mal umgesetzt, allerdings ohne den Errorhandler in eine DLL auszulagern. DLL und Applikation compilieren und linken. Dem CTest wird der korrekte Pointer auf den angelegten ErrorHandler übergeben, die in der Applikation codierte Funktionalität von GenerateError aber nicht ausgeführt. Aber WAS wird denn dann ausgeführt, irgendwo muß die DLL doch eine Funktionsdeklaration her haben? Wohin werden bei der DLL die Errorhander Funktionen gelinkt?

Aber WAS wird denn dann ausgeführt, irgendwo muß die DLL doch eine Funktionsdeklaration her haben? Wohin werden bei der DLL die Errorhander Funktionen gelinkt?

Würde auch gerne wissen was da ausgeführt wird... Sollte die Referenz auf die Methode in Deiner CTest-Instanz ins Leere laufen, dürfte normalerweise ein Laufzeitfehler auftreten... interessant......

Da ich jetzt schnell Feierabend mach, guck ich mir das, sofern zwischenzeitlich niemand ne korrektur zu obigem Code hat, mal an.

Bis denne,
PuerNoctis

CErrorHandler_Base* getHandler(void) {
   static CErrorHandler instance;
   return &instance;
   }

Hab's bei mir mal nachgestellt und es hat funktioniert (allerdings mit GCC und Shared Objects und nicht mit DLLs).

Hilft das?