Wie erstelle ich eine DLL mit C/C++?

[Nasenbaer]

Hi,
ich suche verzweifelt nach der Antwort wie man eine DLL schreibt und zwar so, dass sie ANSI C konform ist.
Ich habe so Tutorials gefunden bei denen MS-spezifscher Code verwendet wurde [extern "C" _declspec(dllexport)] aber, dass bringt mit nicht weiter, weil die DLL u.a. auch zu Borland C++ kompatibel sein muss. Wie mache ich sowas und wie nutze ich sie dann in anderen Programmen?

Mfg Nasenbaer

[Nasenbaer]

Ist es eigentlich möglich aus einer DLL heraus Funktionen des Hauptprogrammes aufzurufen?

Mfg Nasenbaer

[Exxtreme]

Oje. Ich weiss gar nicht ob es überhaupt gayt eine compiler-unabhängige DLL zu kreieren. Ehrlich gesagt habe ich noch nie was mit DLLs am Hut gehabt.

Gruß
Alex

[TK]

@Nasenbaer

Keine Angst, die DLL ist trotzdem mit Borland bzw. sogar mit allen Programmiersprachen kompatibel, die mit DLL's umgehen können. DLL's sind immer gleich, das hat mit ANSI nichts zu tun. DLL's gibts ja nur unter Windows und natürlich ist deren Aufbau genauso wie das ganze Windows von MS.

[Demirug]

1. So was wie eine ANSI C konforme DLL gibt es nicht. Weil ANSI C kein Konzept für dynamiches Binden enthält.

2. Exportiert man aus einer DLL C++ Klassen, Methoden oder Function kann man diese DLL nur noch mit Programme welche mit dem gleichen Compiler erstellt wurde benutzen. Das hat etwas mit der Namesgenerierung von C++ Compiler zu tun.

3. Man kann allerdings "normale" C Funktionen exportieren. Das Verfahren dazu ist aber Compilerabhängig. Deshalb die Frage was du benutzt. Aber selbst dann gibt es noch eine ganze Menge dinge die man beachten muss. Besonders problematisch ist der Heapspeicher.

Ich persönliche exportiere schon seit Jahren meine Sache nur noch mit COM. Und bei .Net ist das ganze jetzt ganz einfach geworden. Aber .Net ist ja für dich keine Option da du zum BC++ kompatibel bleiben willst.

[Nasenbaer]

Wenn das so ist dann verzichte ich mal auf die Compilerunabhängigkeit. :)

Das Problem ist folgendes:
Ich möchte ein Programm schreiben, einen MediaPlayer, bei dem der Multimedia-Teil per PlugIns realisiert wird. Der Visualisierungsteil auch. Soweit ist es nicht problematisch. Aber die GUI soll auch komplett ersetzbar sein.
Deshalb dachte ich baue ich eine Art PlugIn Manager der zwischen den einzelnen DLLs (GUI wollte ich auch als DLL realisieren) die Verknüfungen vornimmt. Dazu müsste die GUI aber Funktionen inerhalb des PlugIn-Managers (welcher im übrigen die letztendlich ausführbare Datei sein soll) aufruft.
Geht sowas? Geht es anders vielleicht besser?

Wie funktioniert das mittels COM bei .NET? Hast du nen MSDN Link oder was ähnliches?

MFg Nasenbaer

[Demirug]

Nasenbaer,

also COM und .Net sind zwei verschiedenen Sache. Wobei für deinen Fall .Net nicht geeignet ist da die Medien API für .Net noch nicht verfügbar ist und es deshalb etwas zu Aufwendig wäre.

Für Plugins eignet sich COM aber ganz gut. Man muss sich aber etwas Zeit nehmen um sich in COM einzuarbeiten.

http://msdn.microsoft.com/library/en-us/dncomg/html/msdn_cpptocom.asp?frame=true

man könnte das ganze auch über dynamisch geladene DLLs realisieren, aber die frage ob das wirklich einfacher ist würde ich aus meiner Sicht der Dinge verneinen.

[Nasenbaer]

Mit dem Prinzip, das hinter .NET steht habe ich mich noch net befasst deshalb bin ich in der Hinsicht unwissend. :)
Naja mit COM hatte ich mal bei DirectSound zu tun aber ich werde es sicherlich hinbekommen.

Aber meine wichtigste Frage ist immer noch ob ich von einer DLL heraus Funkionen inerhalb einer Exe, welche diese DLL nutzt, aufrufen kann. Kanns mir zwar nicht so recht vorstellen aber wer weiß. =)

Ansonsten käme ne neue Frage auf. Wie kann man eine GUI vom am besten komplett austauschbar machen?

Mfg Nasenbaer

[Demirug]

Originally posted by Nasenbaer
Aber meine wichtigste Frage ist immer noch ob ich von einer DLL heraus Funkionen inerhalb einer Exe, welche diese DLL nutzt, aufrufen kann. Kanns mir zwar nicht so recht vorstellen aber wer weiß. =)/SIZE]

Es geht ist aber nicht ganz einfach. Ich mache das in der Regel so das ich eine DLL mit den gemeinsam genutzten COM-Objekten habe. Für jedes Plugin ebenfalls eine DLL die auf die gemeine DLL zugreifen kann. Und dann noch eine EXE die das ganze zusammenbindet.

[SIZE=1]
Ansonsten käme ne neue Frage auf. Wie kann man eine GUI vom am besten komplett austauschbar machen?

Mfg Nasenbaer

Läst sich auch mit Plugin Technik machen. Ist aber schon etwas aufwendig weil man dabei Windows etwas zur mitarbeit überreden muss. Ich würde dir empfelen das ganze Projekt Stück für Stück anzugehen. Also erst ma nur den Player und dann nacheinader die special Features. Alles auf einmal wird dich in die verzweiflung Treiben.

[zeckensack]

Originally posted by Nasenbaer
... Dazu müsste die GUI aber Funktionen inerhalb des PlugIn-Managers (welcher im übrigen die letztendlich ausführbare Datei sein soll) aufruft.
Geht sowas?Du könntest bei der Initialisierung der GUI-DLL einen Funktionszeiger übergeben, halt das was man landläufig callback nennt.

Wenn du viele Funktionen brauchst, dann kannst du dir mit einer struct behelfen, die mehrere Funktionszeiger enthält.

Der Plugin-Manager die ihm bekannten Funktionszeiger in die struct und die Plugins erhalten einen Zeiger auf diese struct bei der Initialisierung.

Ggf kannst du es auch so regeln, daß der Plugin-Manager nur einen Teil der Funktionszeiger reinschreibt und die Plugins den Rest machen lässt.

ZB//Header spi.h
struct shared_plugin_interface
{
int (*display)(Data* data);
bool (*new_data)(void);
};
//Plugin_manager.cpp
#include "spi.h"

shared_plugin_interface spi;
void (*display_plugin_init)(shared_plugin_interface*)=NULL;

bool
new_data()
{
if (something_changed_the_data) return(true);
else return(false);
}

void
spi_init()
{
spi.new_data=new_data();
//load plugin dll
<...>
display_plugin_init=GetProcAddress(<...>);
display_plugin_init(&spi);
}
//display plugin dll source
#include "spi.h"

shared_plugin_interface* spi;

//don't export this
int
display(Data* data)
{
//do something
<...>
}

//but do export this
void
init(shared_plugin_interface* common_interface)
{
spi=common_interface;
//fill in function pointers belonging to display plugin
spi->display=display;
}

[Nasenbaer]

Ist mir alles noch zu kompliziert, denn das beste an der Geschichte ist ja noch, dass dieses Programm dann nach Linux portiert werden sollte.....

Ich werde das wohl von variabler GUI auf einfacheren Skin-Support zurückschrauben, damit ich mich nicht tod mache.
Werde dann die DLLs einfach ohne COM nutzen.
Danke für eure Infos. Ich wäre sonst wohl früher oder später verzweifelt. :)

Mfg Nasenbaer