ich habe 3 fragen zu dlls

1: ich habe in meiner DLL eine Form mit Edit und Label erstellt, beim aufruf der Form aus dem Hauptprogramm wird aber nur die form, und nciht die anderen komponenten angezeigt, wieso?
muss ich für jede komponente eine eigene funktion schreiben?

form sieht so aus:

__declspec(dllexport) void ShowForm(TComponent* Owner)
{
TForm* Form3 = new TForm(Owner);
Form3->ShowModal();
}

2: wie kann ich resourcendateien in dlls verwenden?
also ich möchte eine ressourcendatei mit strings (STRINGTABLE) in meine DLL packen, und dann vom Hauptprogramm aus verwenden, wie mach ich das?

Wenn ich eine Resource zur exe hinzufüge, geht t es ja über LoadStr()

3: wie kann ich selber geschriebene klassen in dlls verwenden?
wie muss ich sie in der dll deklarieren und definieren, und wie kann ich im hauptprogrmm darauf zugreifen??

1. Was erwartets du, wenn du eine Instanz von TForm erstellt? Diese hat keine weiteren Komponenten! Du must natürlich eine Instanz deiner eigenen, von TForm abgeleiteten Klasse erstellen.

Und wenn du etwas mit new erstellst, dann solltest du es auch selber wieder löschen. In der VCL kannst du das zwar dem Owner überlassen. Aber gerade bei DLLs solltest du keiner externe Klasse das Löschen überlassen. Also setzt den Owner lieber auf NULL und löschen nach dem ShowModal selber.

2. Grundsätzlich genauso. Du must nur die rc-Datei in die DLL anstatt in die Exe mit reinkompilieren.

3. Siehe zum Beispiel hier.

bis bald
akari

soll ich da vorgehen, wie bei einer form?

also komponente auf form ziehen, zB Edit und da:

__declspec(dllexport) void ShowForm(TComponent* Owner)
{
TForm* Form3 = new TForm(Owner);
TEdit* Edit1 = new TEdit(Form3);
//hier noch andere sachen fürs edit???
Form3->ShowModal();
}

und zu 2ten:

also die rc zum projekt(der dll hinzufügen) und die rh in der dll cpp includieren?

und wie kann ich dann aus dem Hauptprogramm über die dll die ressource aufrufen?
Soll ich da in der dll eine Funktion schreiben, die das LoadStr() verwendet?
Oder wie genau muss ich da vorgehen?

danke schonmal

soll ich da vorgehen, wie bei einer form?
also komponente auf form ziehen, zB Edit und da:
...

Du könntest es so machen. Allerdings ist das eher unüblich, schließlich kannst du auch in DLLs wie gewohnt zur Entwurfszeit mit dem Objektinspektor deine Form samt Events zusammenstellen.
Nehmen wir mal an du hast so eine Form namens TMyForm mitsamt deinen Controls erstellt, kannst du diese dann so aufrufen

#include "MyForm.h"
...
__declspec(dllexport) void ShowForm()
{
TMyForm* Form = new TMyForm(NULL);
Form->ShowModal();
delete Form;
}

also die rc zum projekt(der dll hinzufügen) und die rh in der dll cpp includieren?

Ja genau.

und wie kann ich dann aus dem Hauptprogramm über die dll die ressource aufrufen?
Soll ich da in der dll eine Funktion schreiben, die das LoadStr() verwendet?
Oder wie genau muss ich da vorgehen?

Nein eine eigene Funktion brauchst du dafür nicht. Damit könntest du allerdings den Zugriff kapseln, und wahrscheinlich auch mit der VCl-Funktion LoadStr arbeiten.

Wenn du hingegen direkt aus der exe auf eine String-Resource der DLL zugreifen willst, must du die WinAPI-Funktion LoadString verwenden.

bis bald
akari

Allerdings das mit den Klassen habe ich immernoch nciht so ganz verstanden, kannst du mir da viell ein minimalbeispiel geben?

also wie die dll und das hauptprogramm aussehen muss??

weiterhin verwirrt mich die sache mit den header der dll, hier im bcb turorial wird nie von header gesprochen!

wie macht man es nun richtig??

sorry für meine vielen fragen

Schau dir einfach noch zusätzlich dieses Tutorial an, da sollten auch deine letzten Fragen erklärt werden.

bis bald
akari

Viell kannst du mir mal ein beispiel geben?Wäre sehr nett!

die informationen in den tutorials bieten dazu irgendwie wenig hilfe, könnt ihr mir das nicht mal hier erklären?

an einem minimalbeispiel, oder nen link wo es wirklich gut beschrieben wird?

habe auch schon gegoogled, aber leider ohne wirklichen erfolg!

danke

das ist doch alles in dem Link von Braunstein drin, unter dem letzten Kapitel Klassen aus einer DLL exportieren:

bis bald
akari

Du brauchst nur die *.h und die *.lib der DLL in Dein Projekt einbinden und kannst dann in Deinem Projekt Objekte der DLL-Klasse erzeugen und verwenden. Nicht mehr und nicht weniger.

(Ist aber meiner Meinung nach eher unüblich. Eigentlich ist es, meiner Meinung nach, praktikabler, wenn eine DLL immer abgeschlossene, eigenständige Funktionen (Blackbox) beinhaltet, an die man vielleicht noch ein paar Parameter übergibt und die sich dann kümmern.)

mein code:
dll_class.h (eine ganz normale unit, welche im projekt der dll zugeordnet ist)

#ifndef dll_classH
#define dll_classH
#include <vcl.h>

#ifdef __DLL__     //für was ist das gut??
# define DLL_EXP __declspec(dllexport)
#else
# define DLL_EXP __declspec(dllimport)
#endif

class DLL_EXP test
{
 public:
  String ShowIt(){return "HALLO";}

};
//---------------------------------------------------------------------------
#endif

dll.cpp (richtige dll datei)

//---------------------------------------------------------------------------

#include <vcl.h>
#include <windows.h>
#include "dll_class.h"
#pragma hdrstop
//---------------------------------------------------------------------------
//   Wichtiger Hinweis zur DLL-Speicherverwaltung, falls die DLL die statische
//   Version der Laufzeitbibliothek (RTL) verwendet:
//
//   Wenn die DLL Funktionen exportiert, die String-Objekte (oder Strukturen/
//   Klassen, die verschachtelte Strings enthalten) als Parameter oder Funktionsergebnisse übergibt,
//   muß die Bibliothek MEMMGR.LIB im DLL-Projekt und anderen Projekten,
//   die die DLL verwenden, vorhanden sein. Sie benötigen MEMMGR.LIB auch dann,
//   wenn andere Projekte, die die DLL verwenden, new- oder delete-Operationen
//   auf Klassen anwenden, die nicht von TObject abgeleitet sind und die aus der DLL exportiert
//   werden. Durch das Hinzufügen von MEMMGR.LIB wird die DLL und deren aufrufende EXEs
//   angewiesen, BORLNDMM.DLL als Speicherverwaltung zu benutzen. In diesem Fall
//   sollte die Datei BORLNDMM.DLL zusammen mit der DLL weitergegeben werden.
//
//   Um die Verwendung von BORLNDMM.DLL, zu vermeiden, sollten String-Informationen als "char *" oder
//   ShortString-Parameter weitergegeben werden.
//
//   Falls die DLL die dynamische Version der RTL verwendet, müssen Sie
//   MEMMGR.LIB nicht explizit angeben.
//---------------------------------------------------------------------------

#pragma argsused
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void* lpReserved)
{
        return 1;
}

__declspec(dllexport)void ReadList(TStringList* myList,TEdit* myEdit)
{
 ShowMessage(myList->Count);
 myList->Add("TEST");
 ShowMessage(myList->Count);
 myEdit->Text = myList->Strings[0];
}
//---------------------------------------------------------------------------

mainform.h (programm welches dll aufruft)

//---------------------------------------------------------------------------

#ifndef mainformcppH
#define mainformcppH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Dialogs.hpp>
#include <Menus.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Von der IDE verwaltete Komponenten
        TOpenDialog *OpenDialog1;
        TMainMenu *MainMenu1;
        TMenuItem *Datei1;
        TMenuItem *ffnen1;
        TEdit *Edit1;
        void __fastcall ffnen1Click(TObject *Sender);
private:	// Anwender-Deklarationen
public:		// Anwender-Deklarationen
        __fastcall TForm1(TComponent* Owner);
        TStringList* VDAList;
};

__declspec(dllimport) void ReadList(TStringList* myList,TEdit* myEdit);
__declspec(dllimport) DLL_EXP test t;  //ausdrucksysntax
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

mainform.cpp (aufruf der funktionen)

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "mainformcpp.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ffnen1Click(TObject *Sender)
{
if(OpenDialog1->Execute())
   {
    VDAList = new TStringList();
    VDAList->LoadFromFile(OpenDialog1->FileName);
    ReadList(VDAList,Edit1);
   }
}
//---------------------------------------------

lib der dll habe ich der mainform mitgegeben
ohne klasse klappt auch alles

also meine frage, was mache ich falsch?

muss die classe direkt mit in die dll datei (dll.cpp)??
wie rufe oder erstelle ich eine instanz dieser klasse in dem aufrufendem programm?(mainform.h/.cpp)

ich bedanke mich schonmal!

ps. fragen stehen als kommenta im code! (sind im code ja nur 2 )

Das hier

ifdef __DLL__     //für was ist das gut??

soll der dll_class.h sagen, ob sie in einer dll (exportieren) oder einem normalen Projekt (importieren) inkludiert wurde.
Du solltest folgendes machen.
las das hier

__declspec(dllimport) DLL_EXP test t;  //ausdrucksysntax

in der mainform.h weg.
Inkludiere in der mainform.cpp die dll_class.h.

und so macht man das wohl immer mit klassen aus dlls?

aber das die klassendeklaration nicht direkt in der dll-datei ist, ist ok so?
oder packt man die eigentlich auch in die dll direkt (so wie die ReadList() Funktion)??

Und überprüf das __DLL__ als Bedingung in dem DLL-Projekt eingetragen ist.

und so macht man das wohl immer mit klassen aus dlls?

Es ist die eleganteste Möglichkeit. Aber natürlich ist das DLL-Interface dann nicht mehr C-Kompatibel.

aber das die klassendeklaration nicht direkt in der dll-datei ist, ist ok so?

Natürlich muß die Klassendeklration auch in dem Projekt integriert sein.

bis bald
akari

Hallo

Und überprüf das __DLL__ als Bedingung in dem DLL-Projekt eingetragen ist.

bis bald
akari

was genau ist damit gemeint?sorry ich arbeite wirklich noch nciht so lang mit dlls!

wo schau ich das nach, bzw ändere ich das?

Menü Projekt/Optionen/Verzeichnisse und Bedingungen, dort ist die Liste der Bedingungen, wo in dem DLL-Projekt der besagte Ausdruck als eigene Zeile eingetragen werden soll.

bis bald
akari

aber das die klassendeklaration nicht direkt in der dll-datei ist, ist ok so?

Natürlich muß die Klassendeklration auch in dem Projekt integriert sein.

bis bald
akari

damit ist aber gemeint, das im der projektansicht, die klassendateien (h.cpp) der dll zugeordnet wurden oder?

ich habe aber gemeint, das die klassen nicht in der hauptdatei der dll (die, die als erstes erstellt wird, wenn ich auf dll-experte und ersellen klicke, erstellt wird) hineinmuss oder?
also es können schon seperate dateien sein, nur eben der dll zugeordnet?!

und bei den bedingungen steht bei mir nur __DEBUG und sonst nix....

und bei den bedingungen steht bei mir nur __DEBUG und sonst nix....

Das reicht auch, siehe mein obiger Post.