Beispiel für Erstellung einer einfachen DLL

  • BCB starten und im Menü ‚Datei->Neu->DLL Experte‘ wählen
  • BCB erstellt nun das Grundgerüst einer DLL (Unit1.cpp):
//---------------------------------------------------------------------------
#include <vcl.h>
#include <windows.h>
#pragma hdrstop
//---------------------------------------------------------------------------
// Wichtiger Hinweis über die 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, solten 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;
}
//---------------------------------------------------------------------------
  • Wir ändern den Quellcode dahingehend, dass er wie folgt aussieht (Kommentare entfernen):
#include <vcl.h>
#include <windows.h>
#pragma hdrstop

#pragma argsused
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void* lpReserved)
{
    return 1;
}
//---------------------------------------------------------------------------
  • Jetzt fügen wir zwei Beispielfunktionen und die entsprechenden Export-Deklarationen ein:
#include <vcl.h>
#include <windows.h>
#pragma hdrstop

// Funktionen für Export zur späteren Anwendung deklarieren
extern "C" __declspec(dllexport) int Addieren(int, int);
extern "C" __declspec(dllexport) void Addieren_mit_Pointer(int *, int*, int*);

#pragma argsused
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void* lpReserved)
{
    return 1;
}
//---------------------------------------------------------------------------
// Funktion zur einfachen Addidtion zweier Zahlen
int Addieren(int Zahl1, int Zahl2)
{
    return Zahl1+Zahl2;
}

// Funktion zur Addition zweier Zahlen über Pointer
void Addieren_mit_Pointer(int *Zahl1, int *Zahl2, int *Ergebnis)
{
    // Die Summe der Pointer Zahl1 und Zahl2 an den Pointer Ergebnis übergeben
    *Ergebnis=*Zahl1+*Zahl2;
}
  • DLL mit Menüpunkt ‚Projekt->Projekt erzeugen‘ generieren
  • Das zugehörige Beispielprogramm (Projekt1.bpr), welches die DLL verwendet, sieht dann wie folgt aus (das Einbinden der *.lib-Datei nicht vergessen!! [siehe Eine DLL in ein BCB Projekt einbinden]):
//---------------------------------------------------------------------------
// Das Beipielprogramm verwendet zwei Buttons und drei Editfelder
//
// Edit1: Zahl1
// Edit2: Zahl2
// Edit3: Ergebnis
// Button1: Zahl1 + Zahl2 = Ergebnis
// Button2: *Zahl1 + *Zahl2 = *Ergebnis
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

// Funktionen, die aus der DLL importiert werden
extern "C" __declspec(dllimport) int Addieren(int, int);
extern "C" __declspec(dllimport) void Addieren_mit_Pointer(int *, int*, int*);
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
    int Ergebnis;

    // DLL-Funktion aufrufen, Rückgabewert ist vom Typ int
    Ergebnis = Addieren(Edit1->Text.ToInt(), Edit2->Text.ToInt());

    Edit3->Text = IntToStr(Ergebnis);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
    int* Zahl1 = new int;
    int* Zahl2 = new int;
    int* Ergebnis = new int;

    *Zahl1 = Edit1->Text.ToInt();
    *Zahl2 = Edit2->Text.ToInt();

    // DLL-Funktion aufrufen
    // Summe von *Zahl1, *Zahl2 steht in *Ergebnis

    Addieren_mit_Pointer(Zahl1, Zahl2, Ergebnis);

    Edit3->Text = IntToStr(*Ergebnis);

    delete Zahl1;
    delete Zahl2;
    delete Ergebnis;
}

Schreibe einen Kommentar