Wo ist die *.lib?

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Du hast absolut keine Elemente (Funktionen, Klassen oder Variablen) Angegeben zum exportieren von daher auch keine LIB.
    Es wird nicht jedes Element extern verlinkbar gemacht solange man es nicht explitziet angibt.

    Bevor ich verrate wie du dein LIB erhällst ein paar allgemeine Infromationen, da du den anscheinend machst wenig zu verstehen was du überhaupt machst. (Nicht böse gemeint)

    Du arbeitest anscheinend mit Visual Studio, dies ist auch für den Anfang auch zu empfehlen.
    Du kannst bei jedem deiner Projekte standartmässig in der Toolleiste auswählen wie du dein Projekt compilieren willst, entweder als Debug-Version oder als Release-Version:
    - Die Debug-Version ist dafür da um Fehler im Programm zu suchen, dafür werden Fehlersuchinformationen in das Porjekt compiliert und die Datei wird logischerweiße größer und ist von der Entwicklungsumgebung teilweiße oder ganz abhänig, sprich man kann es unter umständen nicht auf einem anderen System ausführen. An diesem Punkt empfehle ich dir durch ein paar deiner Konsolenanwendungen mit dem debugger zu "stepen" um den Programmablauf besser zu verstehen. Schau dir am besten ein paar Debug-Tutorials an (z.B youtube.com/watch?v=z5gBIizwsY0)
    - Die Relase-Version ist dafür da um schliesslich das engültige "fehlerfreie" Programm ohne zusätzliche Infromationen zu compilieren, welches auch auf anderen Systemen laufen sollte.

    Desweiteren solltest du eventuel ein wenig Ahnung vom Präprozessor haben. Dieser bearbeitet alle Befehle die mit einer Raute (#) anfängt bevor der Quellcode compiliert, also bevor aus dem eigentlichen Code die verschiedenen Programme generiert werden.
    - #include <dateiname> : Dieser Ausdruck wird vollständig durch den Inhalt der Datei "dateiname" ersetz, welche im Suchpfad des Compiliers liegen muss.
    - #include "pfadzurhead": Dieser Ausdruck wird wird vollständig durch den Inhalt der Datei "pfadzurhead" ersetz, welche relativ zum Projektordner vorliegen muss.
    - #define xyz qrs: Dieser Ausdruck definiert ein MACRO (!) names xyz. Alle darauffolgenden Text die mit dem Macronamen entsprechen werden durch qrs (muss keinen eindeutigen wert haben) ersetz. MACROs können auch dem Präprocessor direkt als Argument vordefiniert übergeben werden. In VSxx ist ein solcher vordefinierter MACRO _USRDLL, sprich mit diesem MACRO gibt der Proprocässer an das es sich um eine DLL handelt, ist diese nicht definiert wird es sich im Projekt um einen anderen Programmtyp handeln.
    Solche Prärocessorederiktiven gibt es noch mehr und sind teilweiße Programmierumgebung abhängig.

    Headerdateien (*.h *.hpp) und Quellcodedateien (*.c *.cpp): Was ist für was? [Hast du in deinem Quellcod soweit ich gesehen habe richtig gemacht]
    In die Quellcoddateien kommen die Definitionen hinein, das ist die endgültige Funktionsweiße einer Klasse, Funktion.
    In die headerdatei hingegen kommen die Deklarationen hinein, dlso nur die Struktur und nicht die eindeutige Funktionswiße.


    Nun zum lösen deines Problems:
    Als erstes solltest du all diese Definitionen aus den Cpp- und Hpp -Dateien entfernen (Die sind eigentlich gänzlich Falsch):

    Quellcode

    1. #if defined(_MSC_VER)
    2. #include "Bogenschuetzen.hpp"
    3. #define DLL extern "C" __declspec(dllexport)
    4. #else
    5. #define DLL
    6. #endif


    In den Cpp-Dateien lasst du einfach die dazugehörige H-Datei einbindung:

    Quellcode

    1. #include "Bogenschuetzen.hpp"


    Ist dies getahn solltest du in alle deine H-Dateien wie mein Lehrer so schön sagt einen Include-Wächter einbauen und zwar auf die Art, das beugt die vor das du später in größeren Projekten mehrmals die selbe Datei einbindest und dies zu doppelten Deklerationen fürt.

    Quellcode

    1. #ifndef _BOGENSCHUETZEN_HPP_
    2. #define _BOGENSCHUETZEN_HPP_
    4. // Code Der HPP Datei
    6. #endif // _BOGENSCHUETZEN_HPP_


    Nun kommen wir zum kompileren der DLL und zum exportieren und importieren von Funktionen, Klassen und Variablen.
    Um die Präprozessordirektiven für dein Projekt zu Managed empfehle ich dir eine weitere Headerdatei zu erstellen und die ganz einfach "dllmain.hpp" zu nenen die du wie follgt dann gestalltest:

    Quellcode

    1. #ifndef _DLLMAIN_HPP_ // Start des
    2. #define _DLLMAIN_HPP_ // Include-Waechter
    4. #if _USRDLL // Wird die Biblitohek exportiert oder importiert
    5. #define DLL_API __declspec(dllexport)
    6. #else
    7. #define DLL_API __declspec(dllimport)
    8. #endif
    10. #endif // _DLLMAIN_HPP_ (Ende des Include-Waechters)


    Diese Datei bindest du in alle deine Headerdatein ein, in dennen du etwas exportieren willst, unzwar nach dem Start des jeweiligen Include-Wächters, in etwa so:

    Quellcode

    1. #ifndef _BOGENSCHUETZEN_HPP_
    2. #define _BOGENSCHUETZEN_HPP_
    4. #include "dllmain.h"
    6. ...


    Nun zum exportieren und importieren musst du alle Funktionen, Klassen und Variablen die du halt exportieren willst in den Headerdateien mit dem Macro DLL_API, der in der dllmain.h Programmtyp abhängig definiert wird, versehen.
    Beispiel:

    Quellcode

    1. // Fuer Klassen
    2. class DLL_API Ctest
    3. {
    4. public:
    5. Ctest(void);
    6. };
    8. // Fuer Variablen
    9. extern DLL_API int ntest;
    11. // Fuer Funktionen
    12. DLL_API int fntest(void);
    Alles anzeigen


    Hast du dies getan kannst du dein Projekt als Release compilieren! Insofern mit dem Macro DLL_API versehende Elemente deklariert wurden, wird eine dazugeörige LIB-Dateie erstellt.

    Nun hast du eine DLL-Datei, eine LIB-Datei und eine gut Funktionierende Headerstruktur aufgebaut.

    Um nun die gewünschten Elemente in deinem externen Programm zu verwenden brauchst du nur die LIB-Datei zu linken und die schon bereits vorhandenen Heaerdateien einfach in dein zweites Projekt zu übernehmen und mittel include einbinden.
    Da du nun in deinem "Exe" Programm keine DLL mehr erstellst und damit das Projekt den Präprocessor _USRDLL nicht mer vorweißt wird der MACRO DLL_API als import deklariert und alle Klassen, Funcitonen etc. die mit DLL_API versehen sind werden als import angesehen.
    (Achtung wenn du eine Elemente aus einer DLL in einer DLL verwenden möchtest wird diese Art der Macrodefinition nicht zum gewünschten Ergebniss führen, da in beiden Fällen _USRDLL vordefiniert ist!)

    Die verwendung der Funktionen etc. ist dann wie gewöhnlich durchzuführen.

    Mfg Rushh0ur

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Rushh0ur ()

  • Danke, vieles ab "Nun zu deinem Problem:" habe ich noch nicht gewusst. ;)


    Eine Sache noch: "Für Klassen" muss man da die ganze Klasse noch einmal schreiben? Ist in dem Beispiel nicht ganz einsichtig.
    Zweite Sache: Die *.lib wird trotz allem nicht erstellt.

    Projekt²

    MfG
    Check

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von Checkmateing ()

  • Ah das sieht doch nun viel besser aus :)

    Nein die Klasse musst du nicht neu schreiben sondern verwendest die Dekleration in den Headerdateien.

    Den programtypabhängigen MACRO hast DLL gennant, das ist auch gut, aber hier noch am rande gesagt sollte man eindeutige Macronamen verwenden!

    Nun wie schon im ersten Post erwähnt musst du durch alle deine Headerdateien gehen und alle Elemente mit dem Maco, in deinem Fall DLL, versehen:

    Quellcode

    1. #ifndef AXTKAEMPFER_HPP
    2. #define AXTKAEMPFER_HPP
    3. #include <iostream>
    4. #include "main.hpp"
    6. class DLL CAxtkaempfer // <------------ Klasse soll exportiert bzw importiert werden also diese mit dem Macro DLL versehen
    7. {
    8. private:
    9. int m_Live;
    10. int m_Attack, m_DefenseBT, m_DefenseRT;
    11. public:
    12. CAxtkaempfer();
    13. };
    14. #endif
    Alles anzeigen


    Mfg Rushh0ur

  • Um die Objekte/Elemente in deiner EXE z verwenden kopierst du alle Headerdateien aus deinem DLL-Porjekt in dein EXE-Projekt.

    Verlinkst die LIB-Datei und bindest die jweiligen Headerdateien die du verwenden willst in deinen Source ein in diesem kannst du dann die Objekte ganz normal verwendnen:

    Quellcode

    1. #pragma comment(lib, "Mittelalter 2.lib")
    2. #include "Axtkaempfer.hpp"
    4. int main()
    5. {
    6. CAxtkaempfer Meinheld;
    7. return 0;
    8. }


    Mfg Rushh0ur

  • Nun ja da bei dir der Headercode zur Zeit größer ist als dein Quellcode macht das ziemlich wenig Sinn.

    BIbliotheken (DLLs) werden deswegen meisten verwendet um Mehrere zussamenhängende Funktionen in einem Modul zu verfasse nund eine Schnitsstelle bereitzustellen zum Beispiel eien DLL die für die Grafik zuständig ist ne andere zur Berechnung der Physik etc.

    Mfg Rushh0ur

  • Ja, das ist ja auch der Aufbau der meisten Engines.

    Was ich jetzt nur noch ein bisschen lustig finde, wenn ich das tue:

    Quellcode

    1. #pragma comment(lib, "Mittelalter 2.lib")
    2. #include "Axtkaempfer.hpp"
    4. int main()
    5. {
    6. CAxtkaempfer Axtkaempfer;
    7. return (0);
    8. }

    wird Axtkaempfer.hpp nicht eingebunden. Die *.lib + *.dll ist im gleichem Ordner. ;]
    Was ist das bitte? Ö.ô

    MfG
    Check

  • Ist den die "Axtkaempfer.hpp" Datei auch im Suchpfad bzw. im selben Ordner?

    Ich hab mal ein komplettes Beispielporjekt anhand dieses Wiki-Eintrags erstellt, sprich die Bruchklasse habe ich in eine DLL ausgelagert.

    Hier die Visualstudio C++ 2008 Projektmappe zum download, solltest du ohne Probleme mit VS10 konventieren, öffnen und compilieren können. Klick.

    Mfg Rushh0ur