Folgendes:

Ich habe verschiedene Headerdateien einer dll. Zum Beispiel

Header.hpp

...
LIntExport Herror decode_2d_bar_code(const HTuple&,const HTuple&,const HTuple&);
LIntExport Herror get_2d_bar_code_pos(const Hobject&,const Hobject&,);
LIntExport Herror find_2d_bar_code(const Hobject&,Hobject*);
LIntExport Herror gen_2d_bar_code_descr(const HTuple&,const HTuple&,HTuple*);
LIntExport Herror discrete_1d_bar_code(const HTuple&,const HTuple&,HTuple*);
...

Daraus hole ich mir für jede Funktion den Namen, Rückgabewert und die Parameter. Die habe ich also als Strings schon vorliegen.

Wenn ich jetzt in meinem Programm eine dieser Funktionen auswähle, möchte ich sie aufrufen. Ich hatte mir das so in etwa vorgestellt:

dll-wrapper.cpp

// In argc steht die Anzahl der Strings, die ich übergebe.
// argv hat etwa folgenden Aufbau: func_name, return_value, param_type_1, 
// param_1, param_type_2, param_2, .., param_type_n, param_n
void call_dll_function(int argc, int argv[])
{
    // Zuerst werden die Parameter ausgewertet (Typ und Wert)
    if(param_typ == "unsigned char") {
        ...
    }

    // Wenn ich alles hingebogen habe, möchte ich die entsprechende Funktion 
    // jetzt aufrufen und das Ergebnis zurückliefern
    ???
}

Ich hoffe, ich konnte rüberbringen, was ich machen möchte. Die einzelnen Funktionen hardcoden geht nicht, da es jetzt schon über 800 sind und sich ständig ändern können.

Hat jemand einen Vorschlag, wie man das realisieren könnte?

Ansonsten solltest du mal erklären, was du eigentlich dort vorhast.

Sinn und Zweck:

Die Libraries, die vorliegen sind Bildverarbeitungsroutinen. Mit vielen hundert Funktionen. Ich möchte (oder besser muss) nun aus LabVIEW (grafische Prog-Sprache) zur Laufzeit heraus dynamisch auf diese Funktionen zugreifen. In LabVIEW soll ein User alle verfügbaren Funktionen angezeigt bekommen und sich diese nach belieben aneinanderreihen. DLL-Funktionen werden in LabVIEW in einem Call-Library-Node aufgerufen. Da stellt man die Funktion ein, die Parameter und so weiter. Leider kann man das nicht dynamisch zur Laufzeit ändern.
Wenn ich alle DLL-Funktionen nicht hardcoden möchte, brauche ich einen Mechanismus, der mir die Dinger dynamisch identifiziert und aufruft. Ich dachte halt, dass ich im LabVIEW immer nur eine Funktion aufrufe (meinen dll-Wrapper), der dann die Aufrufe an die Bibliotheken weiterleitet.
Denn in LabVIEW geht es halt wie gesagt nicht. Deswegen wollte ich das in C/C++ auslagern.

Leider sind die Parameterlisten auch nicht identisch. Mal gibts 3 Parameter, mal 27. Immer mit den verschiedensten Datentypen.

const char *cFuncname = "myfunc"; // oder als Parameter

typedef void (*MyFunc)(int, unsigned char, const char *);

HINSTANCE hInstLib = LoadLibrary("libname");

MyFunc func = (MyFunc)GetProcAddress(hInstLib, cFuncname);
if(func)
   (*func)(0, 'x', "hello"); // oder hier auch wieder dynamische Werte, aber die Anzahl der Parameter mußt du fest coden

Eine andere Möglichkeit wäre, wenn du direkt den Aufrufstack erzeugst und die entsprechende Funktion dann aufrufst (am besten in Assembler).

CallDll(string fnName, parameterliste...)

diese funktionen aus der Dll aufrufen?

das is übel, glaubich..

Ich denke, dir bleibt nichts anderes übrig, als (wenigstens die Funktionsnamen mit parameterliste hardzucoden.)

Ich würde dann glaub ich versuchen, für jede funktion eine Klasse zu schreiben, die genau diese funktion wrappt, oder eine Klasse für alle Funktionen, die die dinger wrappt, so dass du dann sozusagen die Klasse als funktion hast, den Rest macht die Klasse für sich. Die Klassen müssen aber trotzdem wissen, wie ihre Funktion heißt und welche Parameter die erwartet. Und die muss dann auch mittels GetProcAddress den Funktionspointer aus der Dll laden... aber so müsste es gehen.

Eine andere Möglichkeit wäre, wenn du direkt den Aufrufstack erzeugst und die entsprechende Funktion dann aufrufst (am besten in Assembler).

das is ne coole Idee, aber da musst due die aufrufkonventionen kennen und so, da kann auch mehr schiefgehen als mit loadlibrary und co

Wenn du mal wieder sowas hast, dann wäre es einfacher die Funktionen in einer Skriptsprache wie LUA zu schreiben, dann ist das ganze kein Problem

@Maxi
Die Sache mit den extra-Klassen für jede Funktion wollte ich gerade vermeiden. Denn in der jetzigen Bibliothek sind 6981 Funktionen. Und es ist durchaus möglich, dass die Bibliothek demnächst getauscht wird. Sonst könnte ich es auch im LabVIEW hardcoden.

Wie ich mir schon dachte, ist die Aufgabe ziemlich Hardcore... Mal schauen, ob ich irgendwie einen Weg finde.

Erstmal Danke an alle.

Das Problem an der ganzen Thematik (hat jetzt nichts speziell mit Boost zu tun) ist, das du sehr viel zu Fuss erledigen mußt, damit deine API auf beiden Seiten angesprochen werden kann. Das wirst du mit drei Zeilen C++ Code nicht hinbekommen.

Steht dir der Sourcecode von dieser Labview-Sprache zur Verfügung?

Nee, dass ist ne professionelle Programmiersprache (4000 € pro Lizenz) für den technischen Bereich. Bin wegen Firmenpolitik leider darauf angewiesen.