Главная страница
Навигация по странице:

  • Библиотеки импортирования

  • Согласование интерфейсов

  • Загрузка неявно подключаемой DLL

  • Динамическая загрузка и выгрузка DLL

  • FreeLibrary : ::FreeLibrary(hMyDll); Загрузка MFC-расширений динамических библиотек

  • LoadLibrary и FreeLibrary

  • Ресурсы DLL Динамическая загрузка применима и к ресурсам DLL, используемым MFC для загрузки стандартных ресурсов приложения. Для этого сначала необходимо вызвать функцию LoadLibrary

  • Замечание.

  • FindResource и LoadResource

  • WinMain

  • Пример неявного поключения DLL приложением

  • Пример динамической загрузки DLL приложением

  • Справочник по математике. Справочное_пособие_Visual C++. Программа на C, типы данных и их размер Адресация в С


    Скачать 0.66 Mb.
    НазваниеПрограмма на C, типы данных и их размер Адресация в С
    АнкорСправочник по математике
    Дата19.12.2022
    Размер0.66 Mb.
    Формат файлаpdf
    Имя файлаСправочное_пособие_Visual C++.pdf
    ТипПрограмма
    #852232
    страница7 из 13
    1   2   3   4   5   6   7   8   9   10   ...   13
    void SetRangeMin(int nMin, BOOL bRedraw = FALSE);
    void SetRangeMax(int nMax, BOOL bRedraw = FALSE);
    void SetRange(int nMin, int nMax, BOOL bRedraw = FALSE);
    Первые две функции устанавливают максимальное и минимальное знанение, а третья - устанавливает эти значения из переменных nMax и nMin соответственно. Аргумент bRedraw отвечает за перерисовку слайдера.
    int GetPos() const;
    Возвращает текущую позицию.
    void SetPos(int nPos);
    Устанавливает текущую позицию в nPos.
    BOOL SetTic(int nTic);
    Устанавливает шаг ( nTic ).
    void SetTicFreq(int nFreq);
    Устанавливает частоту засечек ( nFreq ).
    7. Методы класса CSpinButtonCtrl

    int SetPos(int nPos);
    Устанавливает текущую позицию в nPos.
    int GetPos() const;;
    Возвращает текущую позицию.
    void SetRange(int nLower, int nUpper);
    void SetRange32(int nLower, int nUpper);
    Устанавливает максимальное и минимальное знанение из переменных nMax и nMin соответственно.
    void GetRange(int &lower, int& upper) const;
    void GetRange32(int &lower, int& upper) const;;
    Эти две функции записывают максимальное и минимальное знанение в upper и lower соответственно.
    8. Пример Windows-приложения, использующего стандартные ресурсы
    12. Работа с библиотеками динамической компоновки (DLL)
    ·
    Использование DLL o
    Библиотеки импортирования o
    Согласование интерфейсов o
    Загрузка неявно подключаемой DLL o
    Динамическая загрузка и выгрузка DLL o
    Пример обычной DLL и способов загрузки
    ·
    Создание DLL o
    Функция DllMain o
    Экспортирование функций из DLL o
    Экспортирование классов o
    Память DLL o
    Полная компиляция DLL
    ·
    DLL и MFC o
    Обычные MFC DLL o
    Динамические расширения MFC o
    Загрузка динамических расширений MFC o
    Экспортирование функций из динамических расширений
    С самого рождения (или чуть позже) операционная система Windows использовала библиотеки динамической компоновки DLL (Dynamic Link Library), в которых содержались реализации наиболее часто применяемых функций. Наследники Windows — NT и Windows 95, а также OS/2 — тоже зависят от библиотек DLL в плане обеспечения значительной части их функциональных возможностей.
    Рассмотрим ряд аспектов создания и использования библиотек DLL:
    · как статически подключать библиотеки DLL;
    · как динамически загружать библиотеки DLL;
    · как создавать библиотеки DLL;
    · как создавать расширения МFC библиотек DLL.

    Использование DLL
    Практически невозможно создать приложение Windows, в котором не использовались бы библиотеки
    DLL. В DLL содержатся все функции Win32 API и несчетное количество других функций операционных систем Win32.
    Вообще говоря, DLL — это просто наборы функций, собранные в библиотеки. Однако, в отличие от своих статических родственников (файлов . lib), библиотеки DLL не присоединены непосредственно к выполняемым файлам с помощью редактора связей. В выполняемый файл занесена только информация об их местонахождении. В момент выполнения программы загружается вся библиотека целиком. Благодаря этому разные процессы могут пользоваться совместно одними и теми же библиотеками, находящимися в памяти. Такой подход позволяет сократить объем памяти, необходимый для нескольких приложений, использующих много общих библиотек, а также контролировать размеры ЕХЕ-файлов.
    Однако, если библиотека используется только одним приложением, лучше сделать ее обычной, статической. Конечно, если входящие в ее состав функции будут использоваться только в одной программе, можно просто вставить в нее соответствующий файл с исходным текстом.
    Чаще всего проект подключается к DLL статически, или неявно, на этапе компоновки. Загрузкой
    DLL при выполнении программы управляет операционная система. Однако, DLL можно загрузить и явно, или динамически, в ходе работы приложения.
    Библиотеки импортирования
    При статическом подключении DLL имя .lib-файла определяется среди прочих параметров редактора связей в командной строке или на вкладке “Link” диалогового окна “Project Settings” среды Developer
    Studio. Однако .lib-файл, используемый при неявном подключении DLL, — это не обычная статическая библиотека. Такие .lib-файлы называются библиотеками импортирования (import libraries). В них содержится не сам код библиотеки, а только ссылки на все функции, экспортируемые из файла DLL, в котором все и хранится. В результате библиотеки импортирования, как правило, имеют меньший размер, чем DLL-файлы. К способам их создания вернемся позднее. А сейчас рассмотрим другие вопросы, касающиеся неявного подключения динамических библиотек.
    Согласование интерфейсов
    При использовании собственных библиотек или библиотек независимых разработчиков придется обратить внимание на согласование вызова функции с ее прототипом.
    Если бы мир был совершенен, то программистам не пришлось бы беспокоиться о согласовании интерфейсов функций при подключении библиотек — все они были бы одинаковыми. Однако мир далек от совершенства, и многие большие программы написаны с помощью различных библиотек без C++.
    По умолчанию в Visual C++ интерфейсы функций согласуются по правилам C++. Это значит, что параметры заносятся в стек справа налево, вызывающая программа отвечает за их удаление из стека при выходе из функции и расширении ее имени. Расширение имен (name mangling) позволяет редактору связей различать перегруженные функции, т.е. функции с одинаковыми именами, но разными списками аргументов. Однако в старой библиотеке С функции с расширенными именами отсутствуют.
    Хотя все остальные правила вызова функции в С идентичны правилам вызова функции в C++, в библиотеках С имена функций не расширяются. К ним только добавляется впереди символ подчеркивания (_).

    Если необходимо подключить библиотеку на С к приложению на C++, все функции из этой библиотеки придется объявить как внешние в формате С: extern "
    С" int MyOldCFunction(int myParam);
    Объявления функций библиотеки обычно помещаются в файле заголовка этой библиотеки, хотя заголовки большинства библиотек С не рассчитаны на применение в проектах на C++. В этом случае необходимо создать копию файла заголовка и включить в нее модификатор extern "C" к объявлению всех используемых функций библиотеки. Модификатор extern "C" можно применить и к целому блоку, к которому с помощью директивы #tinclude подключен файл старого заголовка С. Таким образом, вместо модификации каждой функции в отдельности можно обойтись всего тремя строками: extern "
    С"
    {
    #include "MyCLib.h"
    }
    В программах для старых версий Windows использовались также соглашения о вызове функций языка PASCAL для функций Windows API. В новых программах следует использовать модификатор winapi, преобразуемый в _stdcall. Хотя это и не стандартный интерфейс функций С или C++, но именно он используется для обращений к функциям Windows API. Однако обычно все это уже учтено в стандартных заголовках Windows.
    Загрузка неявно подключаемой DLL
    При запуске приложение пытается найти все файлы DLL, неявно подключенные к приложению, и поместить их в область оперативной памяти, занимаемую данным процессом. Поиск файлов DLL операционной системой осуществляется в следующей последовательности.
    ·
    Каталог, в котором находится ЕХЕ-файл.
    ·
    Текущий каталог процесса.
    ·
    Системный каталог Windows.
    Если библиотека DLL не обнаружена, приложение выводит диалоговое окно с сообщением о ее отсутствии и путях, по которым осуществлялся поиск. Затем процесс отключается.
    Если нужная библиотека найдена, она помещается в оперативную память процесса, где и остается до его окончания. Теперь приложение может обращаться к функциям, содержащимся в DLL.
    Динамическая загрузка и выгрузка DLL
    Вместо того, чтобы Windows выполняла динамическое связывание с DLL при первой загрузке приложения в оперативную память, можно связать программу с модулем библиотеки во время выполнения программы (при таком способе в процессе создания приложения не нужно использовать библиотеку импорта). В частности, можно определить, какая из библиотек DLL доступна пользователю, или разрешить пользователю выбрать, какая из библиотек будет загружаться. Таким образом можно использовать разные DLL, в которых реализованы одни и те же функции, выполняющие различные действия. Например, приложение, предназначенное для независимой передачи данных, сможет в ходе выполнения принять решение, загружать ли DLL для протокола
    TCP/IP или для другого протокола.
    Загрузка обычной DLL
    Первое, что необходимо сделать при динамической загрузке DLL, - это поместить модуль библиотеки в память процесса. Данная операция выполняется с помощью функции ::LoadLibrary,
    имеющей единственный аргумент – имя загружаемого модуля. Соответствующий фрагмент программы должен выглядеть так:
    HINSTANCE hMyDll;
    …… if((hMyDll=::LoadLibrary(“MyDLL”))==NULL) { /* не удалось загрузить DLL */ } else { /* приложение имеет право пользоваться функциями DLL через hMyDll */ }
    Стандартным расширением файла библиотеки Windows считает .dll, если не указать другое расширение. Если в имени файла указан и путь, то только он будет использоваться для поиска файла.
    В противном случае Windows будет искать файл по той же схеме, что и в случае неявно подключенных DLL, начиная с каталога, из которого загружается exe-файл, и продолжая в соответствии со значением PATH.
    Когда Windows обнаружит файл, его полный путь будет сравнен с путем библиотек DLL, уже загруженных данным процессом. Если обнаружится тождество, вместо загрузки копии приложения возвращвется дескриптор уже подключенной библиотеки.
    Если файл обнаружен и библиотека успешно загрузилась, функция ::LoadLibrary возвращает ее дескриптор, который используется для доступа к функциям библиотеки.
    Перед тем, как использовать функции библиотеки, необходимо получить их адрес. Для этого сначала следует воспользоваться директивой typedef для определения типа указателя на функцию и определить переменую этого нового типа, например:
    // тип PFN_MyFunction будет объявлять указатель на функцию,
    // принимающую указатель на символьный буфер и выдающую значение типа int typedef int (WINAPI *PFN_MyFunction)(char *);
    ……
    PFN_MyFunction pfnMyFunction;
    Затем следует получить дескриптор библиотеки, при помощи которого и определить адреса функций, например адрес фунции с именем MyFunction: hMyDll=::LoadLibrary(“MyDLL”); pfnMyFunction=(PFN_MyFunction)::GetProcAddress(hMyDll,”MyFunction”);
    …… int iCode=(*pfnMyFunction)(“Hello”);
    Адрес функции определяется при помощи функции ::GetProcAddress, ей следует передать имя библиотеки и имя функции. Последнее должно передаваться в том виде, в котором эксаортируется из
    DLL.
    Можно также сослаться на функцию по порядковому номеру, по которому она экспортируется (при этом для создания библиотеки должен использоваться def-файл, об этом будет рассказано далее): pfnMyFunction=(PFN_MyFunction)::GetProcAddress(hMyDll,
    MAKEINTRESOURCE(1));
    После завершения работы с библиотекой динамической компоновки, ее можно выгрузить из памяти процесса с помощью функции ::FreeLibrary:
    ::FreeLibrary(hMyDll);
    Загрузка MFC-расширений динамических библиотек
    При загрузке MFC-расширений для DLL (подробно о которых рассказывается далее) вместо функций
    LoadLibraryи FreeLibrary используются функции AfxLoadLibrary и AfxFreeLibrary. Последние
    почти идентичны функциям Win32 API. Они лишь гарантируют дополнительно, что структуры MFC, инициализированные расширением DLL, не были запорчены другими потоками.
    Ресурсы DLL
    Динамическая загрузка применима и к ресурсам DLL, используемым MFC для загрузки стандартных ресурсов приложения. Для этого сначала необходимо вызвать функцию LoadLibrary и разместить
    DLL в памяти. Затем с помощью функции AfxSetResourceHandle нужно подготовить окно программы к приему ресурсов из вновь загруженной библиотеки. В противном случае ресурсы будут загружаться из файлов, подключенных к выполняемому файлу процесса. Такой подход удобен, если нужно использовать различные наборы ресурсов, например для разных языков.
    Замечание. С помощью функции LoadLibrary можно также загружать в память исполняемые файлы
    (не запускать их на выполнение!). Дескриптор выполняемого модуля может затем использоваться при обращении к функциям FindResource и LoadResource для поиска и загрузки ресурсов приложения. Выгружают модули из памяти также при помощи функции FreeLibrary.
    Пример обычной DLL и способов загрузки
    Приведем исходный код динамически подключаемой библиотеки, которая называется MyDLL и содержит одну функцию MyFunction, которая просто выводит сообщение.
    Сначала в заголовочном файле определяется макроконтстанта EXPORT. Использование этого ключевого слова при определении некоторой функции динамически подключаемой билиотеке позволяет сообщить компоновщику, что эта функция доступна для использования другими программами, в результате чего он заносит ее в библилтеку импорта. Кроме этого, такая функция, точно так же, как и оконная процедура, должна определяться с помощью константы CALLBACK:
    MyDLL.h
    #define EXPORT extern “C” __declspec (dllexport)
    EXPORT int CALLBACK MyFunction(char *str);
    Файл библиотеки также несколько отличается от обычных файлов на языке C для Windows. В нем вместо функции WinMain имеется функция DllMain. Эта функция используется для выполнения инициализации, о чем будет рассказано позже. Для того, чтобы библиотека осталась после ее загрузки в памяти, и можно было вызывать ее функции, необходимо, чтобы ее возвращаемым значением было TRUE:
    MyDLL.c
    #include
    #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 (ее библиотека импорта).
    Пример неявного поключения DLL приложением
    Приведем теперь исходный код простого приложения, которое использует функцию MyFunction из библиотеки MyDLL.dll:

    #include
    #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 приложением
    Приведем теперь полностью исходный код простого приложения, которое использует функцию
    MyFunction из библиотеки MyDLL.dll, используя динамическую загрузку библиотеки:
    #include typedef int (WINAPI *PFN_MyFunction)(char *); int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow)
    {
    HINSTANCE hMyDll; if((hMyDll=LoadLibrary(“MyDLL”))==NULL) return 1;
    PFN_MyFunction pfnMyFunction; pfnMyFunction=(PFN_MyFunction)GetProcAddress(hMyDll,”MyFunction”); int iCode=(*pfnMyFunction)(“Hello”);
    FreeLibrary(hMyDll); return 0;
    }
    Создание DLL
    Теперь, познакомившись с принципами работы библиотек DLL в приложениях, рассмотрим способы их создания. При разработке приложении функции, к которым обращается несколько процессов, желательно размещать в DLL. Это позволяет более рационально использовать память в Windows.
    Проще всего создать новый проект DLL с помощью мастера AppWizard, который автоматически выполняет многие операции. Для простых DLL, таких как рассмотренные в этой главе, необходимо выбрать тип проекта Win32 Dynamic-Link Library. Новому проекту будут присвоены все необходимые параметры для создания библиотеки DLL. Файлы исходных текстов придется добавлять к проекту вручную.
    Если же планируется в полной мере использовать функциональные возможности MFC, такие как документы и представления, или намерены создать сервер автоматизации OLE, лучше выбрать тип
    проекта MFC AppWizard (dll). В этом случае, помимо присвоения проекту параметров для подключения динамических библиотек, мастер проделает некоторую дополнительную работу. В проект будут добавлены необходимые ссылки на библиотеки MFC и файлы исходных текстов, содержащие описание и реализацию в библиотеке DLL объекта класса приложения, производного от
    CWinApp.
    Иногда удобно сначала создать проект типа MFC AppWizard (dll) в качестве тестового приложения, а затем — библиотеку DLL в виде его составной части. В результате DLL в случае необходимости будет создаваться автоматически.
    Функция DllMain
    Большинство библиотек DLL — просто коллекции практически независимых друг от друга функций, экспортируемых в приложения и используемых в них. Кроме функций, предназначенных для экспортирования, в каждой библиотеке DLL есть функция DllMain. Эта функция предназначена для инициализации и очистки DLL. Она пришла на смену функциям
    1   2   3   4   5   6   7   8   9   10   ...   13


    написать администратору сайта