Dynamische Bibliothek

Hallo, für ein Projekt möchte ich gerne eine Art Plugin-Fähigkeit haben.
Dafür möchte ich Bibliotheken dynamisch laden.

Nun ist es so, dass jede dynamische Bibliothek wiederum von einer anderen Bibliothek abhängt. Wie kann ich diese Abhängigkeit "realisieren".

In etwa so:

#include <stdio.h> 
#include <Wichtige Library für hier>

void hellow(void) 
{ 
  Wichtige Funktion();
  printf("Hello World "); 
}

.cpp

void hellow(void);

.h

Wenn ich aus dem hier meine .so bauen möchte.
Wie muss ich dann libWichtigeLibrary verlinken?

SeppJ

Völlig falsches Forum. Das sieht sehr nach C aus, nicht nach C++, außerdem geht es um keine sprachspezifische Frage, sondern ... Ehrlich gesagt ich weiß es nicht, da ich die Frage nicht verstehe.

C++ Forumbot

Dieser Thread wurde von Moderator/in SeppJ aus dem Forum C++ (auch C++0x, bzw. C++11) in das Forum Rund um die Programmierung verschoben.

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

Dieses Posting wurde automatisch erzeugt.

Feld

ich habe nie selbst mit dynamischen Bibliotheken was programmiert, deswegen kann ich dir nur die Richtung angeben.

Als erstes liest bitte durch um was es dabei geht, mir scheint es so, als ob du es nicht verstanden hättest (oder ich verstehe deine Frage falsch)
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1418.html

Danach siehe dir die Funktionen dladdr, dlclose, dlerror, dlopen, dlsym und dlvsym an. Diese sind für das Laden von dynamsichen Bibliotheken zuständig.D.h. du bindest deine Bibliotheken nicht in include ein, sondern diese werden dynamsich, on the fly, geladen. Der einzige Header, der du braucht, ist dlfcn.h - dieser beinhaltet die angesprochene Funktionen.
siehe dir dazu http://en.wikipedia.org/wiki/Dynamic_loading an

Kompiliert wird dann mit dem -ldl flag.

Auf jeden so oder so ähnlich, aner nicht wie du es dir vorstellst.

Danach siehe dir die Funktionen dladdr, dlclose, dlerror, dlopen, dlsym und dlvsym an. Diese sind für das Laden von dynamsichen Bibliotheken zuständig.D.h. du bindest deine Bibliotheken nicht in include ein, sondern diese werden dynamsich, on the fly, geladen.

Gebau diese Funktionen möchte ich für meine "plug-ins" verwenden.
Wie ich ein shared object erstelle ist anhand einfacher Beispiele
zB hier http://www.c-plusplus.net/forum/39519 erklärt.

Wie ich meine Bibliothek dann öffnen kann, ist hier http://www.isotton.com/devel/docs/C++-dlopen-mini-HOWTO/C++-dlopen-mini-HOWTO.html recht gut beschrieben.

Meine Frage bezieht sich noch einmal auf das Erstellen des shared objects.

Ich erkläre erstmal kurz was ich brauche:

Ich schreibe ein Programm, welches Molekül-Bewegungen berechnet. Dafür benötigt ein ein Molekül, das Atome mit x,y,z-Koordinaten hat und die Information welche
Atome verbunden sind.

Dann brauche ich noch meine Funktionen für das Molekül, hauptsächlich irgendwelche Energien, die ich berechne, wenn Atome verschoben werden.

// pseudo
class Molecule
{
  List  Atoms;
  Matrix Connected;

  bool isConnected(Atom, Atom)
  double calcEnergy();
}
class Atom
{
  double x,y,z;
}

Nun gibt es sehr viele Dateiformate, aus denen ich die Informationen gewinnen kann, wie etwa .pqr oder .pdb

Nehme ich zB das .pqr-Format (weil es sehr einfach ist), so kann ich daraus
ein Protein lesen und habe Position (x,y,z), Q (Ladung), Radius gegeben.
Weiterhin stehen in einer solchen Datei CONECT-Einträge, welche mir die chemischen Bindungen beschreiben.

Da ich ständig aus solchen Formaten lesen muss, möchte ich jetzt eine Bibliothek
libPQR schreiben, welche eine Molekül-Struktur mit allen Eigenschaften, die aus dem Dateiformat hervorgehen, zurückliefert

PQRMolecule readPQR(file)
{
  return PQRMolecule;
}

PQRMolecule
{
  LIST PQRAtom;
  LIST PQRConect;
}

PQRAtom
{
  int index,
  p, q,r , ...
}

...

Nun braucht mein Programm einen Weg ein PQRMolecule in ein Molecule zu verwandeln.

Das ist nicht weiter problematisch.

// diese Methode muss die PQRMolecule und meine Molcule Struktur kennen
Molecule createMoleculeFromPQR(PQRMolecule);

Da es aber sehr viele Dateiformate gibt, die mein Programm verwenden können soll, dachte ich an eine Art Plugin-Stelle Architektur.

// Programm

// lese eine Datei und liefere ein Molecule zurück
Molecule readFile( filename)
{
 entscheide anhand Dateiendung, um was es sich handelt
 öffne mit dlopen die zugehörige Library und erstelle Molecule
}

Diese Library, die ich mir dlopen öffne, muss eventuell wie im PQR-Beispiel
noch andere Bibiotheken (wie meine libPQR) verwenden. Nun frage ich mich, wie ich das bei der Erstellung mit angebe.

Nochmal kürzer zusammengefasst:

Programm-Molekül  <- Wrapper für Dateiformat <- Bibliothek für bestimmtes Format
FEST             soll dynamisch geladen werden                   FEST

Bin nicht ganz sicher ob das jetzt gut genug beschrieben ist, aber ich hoffe man kommt drauf, was ich meine
Frohes neues jahr

Feld

Ok, nun glaube ich dein Problem verstanden zu haben, wobei ehrlich zugegeben sehe ich da kein Problem. An der stelle will ich mich wiederholen, dass ich mich mit dem Thema nicht auskenne - deswegen sind alle überlegugen rein logischer Natur.

Ich gehe davon aus, dass du die vorhande Bibliotheken nicht verändern kannst / willst, weil sonst könntest die Aufrufe in anderen Bibliotheken plazieren.

Es ist möglich die Zwischenergebnisse zu speichern. D.h. sobald du weißt, welchen wrapper gebraucht wird, dann lädst du den, bzw. holst dir die Funktionen aus der bibliothek. Wenn ich es jetzt richtig verstanden habe, dann kannst du diese Funktionen nicht direkt einsetzen, weil dafür weitere Funktionen, aus einer anderen Biblithek gebraucht werden. -Sehe aber auch hier kein Problem. Du holst einfach die notwendige Funktion aus der Bibliothek2 (im Bsp. heißt es b2_fkt) und machst dann so einen aufruf.

ergebnis_t ergebnis = wrapper_fkt ( b2_fkt ( paramb2 ), paramb1 );

oder in einer anderen Reihenfolge ... eifnacher gesagt, die raw ergebnisse Zwischenspeichern und dann die N-te Funktion aus der Bibliothek_M aufrufen. Solange die Funktionen sich nicht gegenseitig aufrufen, gibt es immer einen zwischenergebniss ... und wenn sie es doch machen, dann sollte der Konzept überprüft werden