[C++] mit cmake shared library erstellen

E

Entwicklerpages

Mitglied
Hallo Community!
Ich versuche mich gerade an einer (extrem einfachen) Game Engine (2D). Dazu benutze ich die SDL und zum übersetzten cmake (Die GE soll auf allen System laufen). Nun habe ich mir länger die Frage gestellt ob ich die GE als static library oder als shared library anbieten möchte. Ich selbst würde ehr zu shared neigen allerdings habe ich da noch so ein paar denkfehler. Erstens: Kann man zu einer Shared Library eine Static Library dazulinken (die SDL, damit man später nicht mehr darauf zugrefien muss sondern einfach nur meine GE dazulinkt und die Header einbindet) Zweitens: Unter Linux/Unix gibt es ja die lieben shared objects (.so) unter Mac die dynamic librarys (.dylib - ich entwickle auch auf mac) unt unter windows die achsotollen Dynamic Link Libraries (.dll) Soweit ich weis arbeiten .so und .dylib gleich was das importieren angeht (Ich bezeihe mich hier auf die Importheader). Wenn ich das richtig verstandne habe reicht es aus sie beim Übersetzten dem Linker mitzugeben und die Headerdatein im Code anzugeben, woebi die Header wie bei Static Librarys ganz normal (also ohne iergendwelche Import/Export Anweisungen) sind. Unter Windows ist das ja aber vollkomen anders. Dem Linker muss man eine .lib Datei mit den benötigten Informationen für die dll mitgeben und die Headerdatein enthalten Import/Export befehle. Was würdet ihr machne? Shared oder Static? Wenn shared, wie sollte ich das mit dne dlls machen? Unmengen an Präprozessor befehlen?
Wäre nett wenn ihr mir helfen könntet
 
Hi

weiteres Argument für Shared:
Im Fall von neuen Versionen von SDL und anderen verwendeten Sachen (solange keine zu großen Änderungen gemacht wurden) kann man seine eigene Library einfach "updaten", in dem man die Dateien von SDL austauscht. Kein Neukompilieren etc. nötig.

Zum Präprozessor:
Das werden keine Unmengen an Anweisungen, es reicht ca. sowas:
C++: 
#ifdef WIN32
    #define EXPORTIERT __declspec(dllexport)
#else
    #define EXPORTIERT
#endif

EXPORTIERT void funktion1(int a);
EXPORTIERT int funktion2(int b);
...
Einmal das ifdef-Zeug,und dann einfach immer EXPORTIERT verwenden.
Bei Windows werden die passenden Sachen eingesetzt,
und sonst wird eben nichts eingesetzt.

Gruß
 
Besser so:

api.h
C++: 
#ifndef API_H
#define API_H

#if defined(WIN32) || defined(_WIN32)
    #ifdef BUILDING_ENGINE
        #define ENGINE_API __declspec(export)
    #else
        #define ENGINE_API __declspec(import)
    #endif
#else
    #define ENGINE_API
#endif

#endif

engine.h
C++: 
#include "api.h"

ENGINE_API void funktion1(int a);
ENGINE_API int funktion2(int b);

Bei Funktionen ist delcspec(import) zwar optional, aber effizenter. Bei Klassen ist es allerdings notwendig.

Grüße,
Matthias
 
Hi.

Wenn man via CMake eine "shared library" namens Xyz erstellt, dann definiert CMake das Präprozessorsymbol "Xyz_EXPORTS".

Auch kann es ganz nützlich sein, wenn man die Wahl hat, ob man eine shared library baut oder nicht (also auch unter Windows ENGINE_API leer läßt).

Und es muß doch "dllimport" resp. "dllexport" heißen, oder?

C: 
#if defined(WIN32) || defined(_WIN32)
#  ifdef engine_EXPORTS /* automatisch von CMAKE definiert */
#    define ENGINE_API __declspec(dllexport)
#  elif defined(engine_DLL) /* manuell zu definieren */
#    define ENGINE_API __declspec(dllimport)
#  endif
#endif
#ifndef ENGINE_API
#  define ENGINE_API
#endif
Gruß
 
Tut mir elid das ich mich erst jetzt melde und danke für die ganzen Antworten!
Ich hatte einiges zu tun weswegen ich erst jetzt weitermachen kann.
ich bin immernoch nicht sicher ob ich eine shared oder eine static library nehme. Wenn mann bedenkt das es sich um eine 2d Engine handelt stellt sich bei mir die Frage ob es sich lohnt eine shared zu benutzen. Theoretisch braucht die Shared Library sogar länger zum laden wenn man bdenkt das das Betriebssystem zwei Datein in den Speicher laden muss von der er eine erstmal finden muss, anstatt das er eine etwas größere Datei lädt. Praktisch spielt das vermutlich keine Rolle.
Da ich aber in der "Ruhezeit" mir einige gedanken über die Implementierung bzüglich "(Engine-)Plugins" (Zum beispiel ein Physikplugin) denke ich das ich eine shared library benutze.
Dazu aber noch zwei Fragen:

1. Wie sieht es mit der SDL aus? Im Moment (static) kann ich sie direkt zur Engine dazulinken, sodass das Spiel selbst nur die Engine linken muss und nichtmehr die SDL. Geht das noch bei Shared Librarys bzw. darf ich das Rechtlich gesehen überhaupt? (Es soll eine OpenSource Engine werden, vermutlich GPL oder LGPL, allerdings interessiert es mich auch was wäre wenn ich eine komerz. Engine schreiben würde)

2. Ich hab mich schon bei DLL's unter Windoof am Anfang schwer angestellt (Der Grund warum ich static meistens bevorzuge ;) ) Unter Unix mit .so und OS X .dylib ändert dich ja schon wieder das ganze Umfeld.
Nach dem was ich bis jetzt ergoogelt habe scheint Unix sich aber mit Shared Librarys nicht so sehr anzustellen wie Windows. Wenn ich das richtig gesehen habe, funktionieren da Shareds genauso wie statics oder irre ich mich?

Danke für eure Antworten!
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück