Создаем DLL

• Статическая загрузка
• Динамическая загрузка

Сейчас мы рассмотрим для чего нужны DLL (Dynamic Link Library - динамически компануемая библиотека) и как их создавать. DLL- это участок кода хранимый в файле с расширением .dll. Код может быть использован другими программами, но сама посебе библиотека прораммой не является. Вобщем-то, динамически компонуемые библиотеки представляют собой набао скомпилированныых функций. Но у ютих библиотек есть свой особенности, так например, если каккието две или более программы для Windows одновременно исполняются и используют функции, находящиеся в одной DLL, то в памяти будет постоянно находится только одна библиотека, обеспечивая тем самым экономное расходование памяти. Загрузка библиотеки в память может быть статической и динамической.

При статической загрузке DLL автоматически загружается при запуске исользующего ее приложения. Такая DLL содержит экспортируемые функции, описание которых находится в файле библиотеки импорта(import library file - .lib). Для использования статической загрузки вы должны на этапе компоновки к программе додключить .lib файл вашей DLL. В C++ Builder это сводится к включения в проект .lib файла через менджер проектов.

При диамической загрузке вы можете загружать DLL при необходимости, выгрузить ее когода она ненужна. Однако работать с такими библиотеками сложнее чем со статическими. Рассмотрим созздание и использование DLL статической загрузки.

Статическая загрузка

Создадим сперва проект (File / New / DLL). Будет создан проект, содержащий следующее:

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

и длинный коментарий предупреждающий вас о том, что для работо способности вашей DLL необходимо снеи обеспечить поствку некоторых dll если вы используете экземпляры класса String.

Для экспорта и импорта из DLL необходимо использовать моди фикаторы __export и __import соответсвенно. Но в C++ Builder можно использовать новое ключевое слово __delspec() с параметрами dllexport и dllimport соответсвенно. Сами понимаете, что для того чтобы эспортировать функции из библиотеки еужен один заголовочный файл с описаниями _delspec(dllexport) для экспортируемых функций, для импорта функций в приложение вам необходимо будет поставить анологичный заголовочный файл но с _delspec(dllimport) описаниями, что достаточно неудобно. Эта проблема решается легко: добавте в заголовочный файл библиотеки следующее:

#if defined(BUILD_DLL)
#  define DLL_EXP __declspec(dllexport)
#else
# if defined(BUILD_APP)
#  define DLL_EXP __declspec(dllimport)
# else
#  define DLL_EXP
# endif
#endif

в исходном файле DLL напишите #define BUILD_DLL, а вместо __declspec(dllexport) пишите DLL_EXP. При написании программы добавте строчку #define BUILD_APP, и просто подключите заголовочный файл DLL.

Пример DLL: файл P.cpp

//---------------------------------------------------------------------------
#define BUILD_DLL
#include 
#include "p.h"
#pragma hdrstop

//---------------------------------------------------------------------------
// Important note about DLL memory management when your DLL uses the
// static version of the RunTime Library:
//
// If your DLL exports any functions that pass String objects (or structs/
// classes containing nested Strings) as parameter or function results,
// you will need to add the library MEMMGR.LIB to both the DLL project and
// any other projects that use the DLL. You will also need to use MEMMGR.LIB
// if any other projects which use the DLL will be perfomring new or delete
// operations on any non-TObject-derived classes which are exported from the
// DLL. Adding MEMMGR.LIB to your project will change the DLL and its calling
// EXE's to use the BORLNDMM.DLL as their memory manager. In these cases,
// the file BORLNDMM.DLL should be deployed along with your DLL.
// To avoid using BORLNDMM.DLL, pass string information using "char *" or
// ShortString parameters.
//
// If your DLL uses the dynamic version of the RTL, you do not need to
// explicitly add MEMMGR.LIB as this will be done implicitly for you
//-------------------------------------------------------------------------
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void*) {
	return 1;
	}

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

void Message(char *s) {
	i=10;
	Application->MessageBox(s,"From DLL",IDOK);
	}

Файл P.h

#if defined(BUILD_DLL)
# define DLL_EXP __declspec(dllexport)
#else
# if defined(BUILD_APP)
# define DLL_EXP __declspec(dllimport)
# else
# define DLL_EXP
# endif
#endif

DLL_EXP void Message(char *s);
DLL_EXP int i;

Скомпилируйте проект.

Если вы нажмете Run то после завершенния построения будет выдано сообщение что данная программа не можнт быть исполнена (естественно). Теперь напишем вызывающую программу. Втомже каталоге создайде новый проект (File / New Application) в форму поместите одну кнопку и создай обработчик события OnClick. Ваш исполняемый файл должен представлять собой слдующее:

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

//-------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender) {
    char c[10];
    Message("roma");
    for( ; i>0;i--) {
        sprintf(c,"Example %d",i );
        Application->MessageBox("Example of using DLL variable",(char*)c,IDOK);
    }
}

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

Не забудьте об объявлениях в начале файла. Зайдите в менеджер проектов.Там откройте свой проект и добавте .lib файл из предыдушего проект с DLL( правый клик, пункт ADD). Запустите проект.

Как видите, для того, чтобы вашу DLL можно было использовать необходимо три файла: сама DLL, заголовочный файл и библиотечный файл .lib.

Динамическая загрузка

extern "C" void __export  Message(char *s)  {
	Application->MessageBox(s,"From DLL",IDOK);
	}

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

void __fastcall TForm1::Button1Click(TObject *Sender) {
	void (__stdcall *Message)(char *s);
	HINSTANCE dllp = LoadLibrary("p.dll");
	if (dllp) {
		Message= (void(__stdcall *) (char*))
		GetProcAddress(dllp, "_Message");
		if (Message) Message("Hi From Dinamic DLL");
		}
	FreeLibrary(dllp);
	}
//---------------------------------------------------------------------------

Содержимое параграфа "Сущность динамического связывания"

Статическая и динамическая компоновка

Обычная Windows-программа представляет собой исполняемый файл, который обычно создает одно или более окон, а для получения данных от пользователя использует цикл обработки сообщений.

·         Динамически подключаемые библиотеки (DLL), как правило, непосредственно не выполняются и обычно не получают сообщений. Они представляют из себя отдельные файлы с функциями, которые вызываются программами и другими DLL для выполнения определенных задач. DLL активизируется только тогда, когда другой модуль вызывает одну из функций, находящихся в библиотеке.

Рассмотрим сущность динамического и статического связывания (или компоновки)

·         Статическое связывание (static linking) имеет место в процессе связывания программы, когда для создания исполняемого exe-файла связываются воедино разные объектные obj-модули, lib-файлы библиотек и, как правило, скомпилированные res-файлы ресурсов.

·         Термин динамическое связывание (dynamic linking) относится к процессам, которые Windows использует для того, чтобы связать вызов функции в одном из модулей с реальной функцией из DLL. В отличие от статического связывания динамическое связывание имеет место во время выполнения программы. В выполняемый файл занесена только информация о местонахождении функций DLL (эту информацию приложение получает из так называемых библиотек импорта).

В момент выполнения программы загружается вся библиотека целиком. Благодаря этому разные процессы могут пользоваться совместно библиотеками, находящимися в памяти. Такой подход позволяет сократить объем памяти, необходимый для нескольких приложений, использующих много общих библиотек, а также контролировать размеры exe-файлов.

• Некоторые динамически подключаемые библиотеки (например, файлы шрифтов) содержат только ресурсы. В них содержатся только данные (обычно в виде ресурсов), и практически нет программного кода.

Таким образом, одной целей существования динамически подключаемых библиотек является обеспечение приложений функциями и ресурсами, которые можно использовать во многих, совершенно разных программах.

Хотя модуль динамически подключаемой библиотеки может иметь любое расширение (.exe или .fon), стандартным расширением, принятым в Windows, является .dll.

• Только те DLL, которые имеют расширение .dll, Windows загрузит автоматически. Если файл имеет другое расширение, то приложение должно загрузить модуль библиотеки явно. Для этого используется функция LoadLibrary или LoadLibraryEx.

Как правило, наибольший смысл DLL приобретают в контексте большого проекта (или пакета приложений). Обычно в таких программах используются некоторые общие подпрограммы.

·         Эти подпрограммы можно поместить в обычную объектную библиотеку (файл с расширением .lib) и добавить ее к каждому программному модулю при компоновке. Но такой подход избыточен, поскольку в этом случае в каждой программе будет находиться одинаковый код подпрограмм, выполняющих одни и те же задачи.

·         Более того, при изменении одной из подпрограмм в библиотеке, необходимо перекомпоновывать все программы, в состав которых входит эта подпрограмма.

·         Однако если поместить все эти общеиспользуемые подпрограммы в динамически подключаемую библиотеку, то обе проблемы будут решены. Только в одном библиотечном модуле нужно содержать необходимые всем приложениям подпрограммы, и можно изменить библиотечный модуль без перекомпоновки приложений.

Три значения одного слова “библиотека”

В предыдущем изложении слово “библиотека” встречается в разных контекстах. Помимо динамически подключаемых библиотек оно упоминается в сочетаниях “объектная библиотек” и “библиотека импорта”. Разберемся в этих понятиях.

Объектная библиотека – это файл с расширением .lib, в котором содержится код, добавляемый к коду программы, находящемуся в файле c расширением .exe, когда идет компоновка программы.

·         Например, в Microsoft Visual C++ обычная объектная библиотека времени выполнения, которая при компоновке присоединяется к программе, называется libc.lib.

Библиотека импорта представляет собой особую форму файла объектной библиотеки. Так же как объектные библиотеки, библиотека импорта имеет расширение .lib и используется компоновщиком для разрешения ссылок на функции в исходном тексте программы. Однако в библиотеках импорта программного кода нет. Вместо них в библиотеках импорта находится информация, необходимая компоновщику для установки таблицы ссылок внутри exe-файла, предназначенной для динамического связывания.

Объектные библиотеки и библиотеки импорта (создаваемые одновременно с модулем DLL) используются только на этапе разработки программы. Динамически подключаемые библиотеки используются во время выполнения программы. Динамически подключаемая библиотека должна находится на диске, когда выполняется программа, использующая эту библиотеку.

• Если операционной системе Windows требуется самостоятельно загрузить модуль динамически подключаемой библиотеки, то файл DLL-библиотеки должен храниться в том же каталоге, что и exe-файл программы, или в текущем каталоге, или в системном каталоге Windows, или в каталоге, доступном из переменной PATH окружения DOS. Именно в таком порядке происходит поиск.

Пример простой DLL

 Замечание. Сделаем предварительные замечания для C++-программистов о соглашении языка С++ об именах функций. Это замечание необходимо потому, что очень много библиотек написаны при помощи разных компиляторов без использования языка C++, в связи с чем в процессе создания cpp-проекта при работе с функциями этих библиотек могут быть проблемы.

• Трансляторы языка С++ к исходному имени функции, определенной в тексте программы, добавляют символы, обозначающие типы аргументов и тип возвращаемого значения (имена функций расширяются). Хотя все остальные правила вызова функции в C идентичны правилам вызова функций в C++, в библиотеках C имена функций не расширяются. К ним только добавляется символ подчеркивания.

Поэтому,

• Если необходимо подключить библиотеку на C к приложению на C++, все функции из этой библиотеки придется объявить как внешние в формате C. Это делается так:

        extern “C” int Function(int Param);

• Если все функции библиотеки объявлены во включаемом файле MyLib.h, то модификатор extern можно применить к целому блоку, к которому с помощью директивы #include подключен файл заголовков С-функций из DLL:

        extern “C” 

        {

               #include “MyLib.h”

        }

Рассмотрим теперь процесс создания и использования DLL в самом легком варианте.

Приведем исходный код простейшей библиотеки динамической компоновки, которая называется MyDLL и содержит одну функцию MyFunction, которая просто выводит сообщение

MyDLL.h

        #define EXPORT extern “C” __declspec (dllexport)

        EXPORT int CALLBACK MyFunction(char *str);

MyDLL.c

        #include <windows.h>

        #include “MyDLL.h”

        int WINAPI DllMain(HINSTANCE hInstance, DWORD fdReason, PVOID pvReserved)

        {

               return TRUE;

        }

        EXPORT int CALLBACK MyFunction(char *str)

        {

               MessageBox(NULL,str,”Function from DLL”,MB_OK);

               return 1;

        }

• После трансляции и компоновки этих файлов появляются два файла – MyDLL.dll (сама динамически подключаемая библиотека) и MyDLL.lib (ее библиотека импорта).

Обратим внимание на то, что сначала в заголовочном файле определяется макроконстанта EXPORT. Она используется затем при объявлении функций DLL, которые будут доступны приложениям, загрузившим эту DLL.

• Использование макроконстанты EXPORT (определяемой в заголовочном файле библиотеки) при определении некоторой функции динамически подключаемой библиотеке позволяет сообщить компоновщику, что эта функция доступна для использования другими программами, в результате чего он заносит ее в библиотеку импорта. Кроме этого, такая функция, точно так же, как и оконная процедура, должна определяться с помощью константы CALLBACK.

Файл библиотеки также несколько отличается от обычных файлов на языке C для Windows. В файле библиотеки вместо функции WinMain имеется функция DllMain. Эта функция используется для выполнения инициализации, о чем будет рассказано позже. Для того чтобы библиотека осталась после ее загрузки в памяти, и можно было вызывать ее функции, необходимо, чтобы возвращаемым значением функции DllMain было TRUE.

Перейдем к обсуждению процесса использования созданной DLL-библиотеки.

Приведем теперь исходный код простого приложения, которое использует функцию MyFunction из библиотеки MyDLL.dll:

MyApp.c

        #include <windows.h>

        #include “MyDLL.h”

        int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)

        {

               int iCode=MyFunction(“Hello”);

               return 0;

        }

• Эта программа выглядит как обычная программ для Windows, чем она в сущности и является. Тем не менее, следует обратить внимание, что в исходный текст программы помимо вызова функции MyFunction из DLL-библиотеки включен и заголовочный файл этой библиотеки MyDLL.h. Также необходимо на этапе компоновки приложения подключить к нему библиотеку импорта MyDLL.lib (процесс неявного подключения DLL к исполняемому модулю).

Чрезвычайно важно понимать, что сам код функции MyFunction не включается в файл MyApp.exe. Вместо этого там просто имеется ссылка на файл MyDLL.dll и ссылка на функцию MyFunction, которая находится в этом файле. Файл MyApp.exe требует запуска файла MyDLL.dll.

·         Заголовочный файл MyDLL.h включен в файл с исходным текстом программы MyApp.c точно так же, как туда включен файл windows.h. Включение библиотеки импорта MyDLL.lib для компоновки аналогично включению туда всех библиотек импорта Windows.

·         Когда программа MyApp.exe работает, она подключается к библиотеке MyDLL.dll точно так же, как ко всем стандартным динамически подключаемым библиотекам Windows.

Сделаем еще несколько замечаний о свойствах DLL.

• Поскольку код модулей приложений и динамически подключаемых библиотек защищен о записи, один и тот же код DLL может использоваться разными процессами. Однако данные, с которыми работает DLL – для каждого процесса свои. Каждый процесс имеет собственное адресное пространство для всех данных, которые использует DLL. Разделение памяти между процессами требует, как будет видно дальше, дополнительных усилий.

• DLL – это не только расширение Windows, это еще и дополнение приложения, которое ее использует. Все, что делает динамически подключаемая библиотека, делается от имени приложения. Например, владельцем всей выделяемой библиотекой памяти является приложение. Владельцем всех создаваемых библиотекой окон является приложение. Владельцем всех открываемых библиотекой файлов является приложение.

• Несколько приложений могут использовать одну и ту же динамически подключаемую библиотеку. Однако если написать динамически подключаемую библиотеку с функциями, которые могут вызваться из нескольких потоков программы, компилировать библиотеку следует с такими же опциями, как и многопоточное приложение.