C Builder как подключить dll

Обновлено: 01.07.2024

Спасибо. Мы получили ваш запрос и незамедлительно ответим.

Присоединяйтесь к нам!

  • Общаться с другими участниками
  • Уведомления об ответах
    на ваши сообщения
  • Поиск по ключевым словам
  • Доступ в один клик к вашим
    любимым форумам
  • Автоматические подписи
    на ваших сообщениях
  • Лучше всего то, что это бесплатно!

*Функции Tek-Tips зависят от того, получают ли участники электронную почту. Присоединяясь, вы соглашаетесь на получение электронной почты.

Правила публикации

Реклама, продажа, рекрутинг, размещение курсовых и дипломных работ запрещено.

Импорт DLL VC++ в C++Builder

Импорт DLL VC++ в C++Builder

Я знаю, что есть хорошая веб-страница с его описанием, но сайт, похоже, не работает.

^ Там он был, но я думаю, что его уже нет.

Может ли кто-нибудь указать мне на другой ресурс о том, как это сделать?

В какой-то момент он разрешил пользователям загружать его сайт. Так что это из моих архивов.

Цитата:

Использование библиотек DLL Visual C++ в проекте C++Builder

Вполне вероятно, что однажды ваш босс спросит вас, можете ли вы создать графический интерфейс с помощью C++Builder, который взаимодействует с существующей 32-разрядной библиотекой DLL, скомпилированной с помощью Microsoft Visual C++. Часто исходный код DLL будет недоступен для вас либо потому, что DLL поставляется сторонним поставщиком, либо потому, что 22-летний стажер только что удалил каталог \DLL\SRC из сети. В этой статье показано, как вызвать DLL из вашего проекта C++Builder с помощью библиотеки DLL и файла заголовка.

* Вызов функций DLL из проекта C++Builder
* Проблема с библиотеками DLL Visual C++
* Шаг 1. Определите соглашения о вызовах, используемые DLL Visual C++
* Шаг 2: Изучите имена компоновщиков в DLL
* Шаг 3. Создайте библиотеку импорта для библиотеки DLL Visual C++
* Шаг 4. Добавьте библиотеку импорта в свой проект
* Заключение

Вызов функций DLL из проекта C++Builder

Вызов библиотеки DLL, созданной с помощью Visual C++, ставит программистов C++Builder перед некоторыми уникальными проблемами. Прежде чем мы попытаемся разобраться с DLL, сгенерированными Visual C++, может быть полезно рассмотреть, как вы вызываете DLL, созданную с помощью C++Builder. Библиотека DLL, созданная с помощью C++Builder, создает меньше препятствий, чем библиотека, созданная с помощью Visual C++.

В листингах A и B содержится исходный код библиотеки DLL, которая может служить тестовой библиотекой DLL. Обратите внимание, что тестовый код реализует два разных соглашения о вызовах (__stdcall и __cdecl). Это по очень хорошей причине. Когда вы пытаетесь вызвать библиотеку DLL, скомпилированную с помощью Visual C++, большинство ваших головных болей будет вызвано разногласиями из-за соглашений о вызовах. Также обратите внимание, что одна функция явно не перечисляет соглашение о вызовах, которое она использует. Эта неизвестная функция будет действовать как мерка для функций DLL, которые не указывают соглашение о вызовах.

FUNCTION int __stdcall StdCallFunction(int Value);
FUNCTION int __cdecl CdeclFunction (int Value);
FUNCTION int UnknownFunction(int Value);

FUNCTION int __stdcall StdCallFunction(int Value)
return Value + 1;
>

FUNCTION int __cdecl CdeclFunction(int Value)
return Value + 2;
>

FUNCTION int UnknownFunction(int Value)
return Value;
>

Сохраните проект как BCBDLL.BPR. Затем скомпилируйте проект и посмотрите на полученные файлы. C++Builder создает как DLL, так и библиотеку импорта с расширением .LIB.

Проблема с библиотеками DLL Visual C++

В идеальном мире вызов библиотеки DLL, созданной с помощью Visual C++, будет не сложнее, чем вызов библиотеки DLL, созданной с помощью C++Builder. К сожалению, Borland и Microsoft расходятся во мнениях по нескольким пунктам. Во-первых, Borland и Microsoft расходятся во мнениях относительно форматов файлов для OBJ и файлов импортируемых библиотек (Visual C++ использует формат библиотеки COFF, а Borland использует OMF). Это означает, что вы не можете добавить созданную Microsoft библиотеку импорта в проект C++Builder. Благодаря утилите Borland IMPLIB различия в форматах файлов преодолимы.

Эти два продукта также расходятся в соглашениях об именах компоновщиков. Это оказывается основным препятствием при попытке вызвать DLL Visual C++ из C++Builder. Каждая функция в DLL или OBJ имеет имя компоновщика. Компоновщик использует имя компоновщика для разрешения функций, которые были прототипированы во время компиляции. Компоновщик сгенерирует неразрешенную внешнюю ошибку, если не сможет найти функцию с именем компоновщика, которое, по его мнению, необходимо программе.

Что касается имен функций компоновщика, Borland и Microsoft расходятся во мнениях по следующим пунктам:

* 1- Visual C++ иногда украшает экспортированные функции __stdcall.
* 2- Borland C++Builder ожидает, что импортированные функции __cdecl будут оформлены.

Стратегия атаки для преодоления этих трех проблем будет зависеть от того, как была скомпилирована библиотека DLL Visual C++. Я разбил процесс на четыре этапа.

Шаг 1. Определите соглашения о вызовах, используемые библиотекой DLL Visual C++

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

__declspec(dllimport) void CALLING_CONVENTION MyFunction(int nArg);

CALLING_CONVENTION должен быть __stdcall или __cdecl (конкретные примеры см. в листинге A). Во многих случаях соглашение о вызовах не указывается, и в этом случае по умолчанию используется __cdecl.

Шаг 2. Проверьте имена компоновщиков в DLL

Если на шаге 1 выяснится, что библиотека DLL использует соглашение о вызовах __stdcall, вам потребуется изучить библиотеку DLL, чтобы определить соглашение об именовании, которому следовал Visual C++ при создании библиотеки DLL. Visual C++ украшает функции __stdcall по умолчанию, но программист DLL может запретить украшение имен, если он добавляет в свой проект файл DEF. Ваша работа будет немного более утомительной, если поставщик DLL не использует файл DEF.

Утилита командной строки TDUMP позволяет проверить имена компоновщика функций, экспортируемых библиотекой DLL. Следующая команда вызывает TDUMP для библиотеки DLL.

TDUMP -ee -m MYDLL.DLL > MYDLL.LST

TDUMP может сообщить массу информации о DLL. Нас интересуют только функции, экспортируемые DLL. Опция команды -ee указывает TDUMP отображать только информацию об экспорте. Переключатель -m указывает TDUMP показывать функции DLL в их необработанном формате. Без ключа -m TDUMP попытался бы преобразовать оформленные функции в удобочитаемый формат. Если DLL большая, вы можете перенаправить вывод TDUMP в файл (через дополнение > MYDLL.LST).

Вывод TDUMP для тестовой библиотеки DLL в листингах A и B выглядит следующим образом:

Turbo Dump Version 5.0.16.4 Copyright (c) 1988, 1998 Borland International
Отображение файла DLL.DLL

ЭКСПОРТ ord:0000='CdeclFunction'
ЭКСПОРТ ord:0002='UnknownFunction'
ЭКСПОРТ ord:0001='_StdCallFunction@4'

Обратите внимание на подчеркивание в начале и @4 в конце функции __stdcall. __cdecl и неизвестная функция не содержат никаких украшений. Если бы библиотека DLL Visual C++ была скомпилирована с файлом DEF, оформление функции __stdcall отсутствовало бы.

Шаг 3. Создайте библиотеку импорта для библиотеки DLL Visual C++

А вот и самое сложное. Из-за различий в форматах файлов библиотек между C++Builder и Visual C++ нельзя добавить библиотеку импорта, созданную с помощью Visual C++, в проект C++Builder. Вы должны создать библиотеку импорта OMF с помощью инструментов командной строки, поставляемых с C++Builder. В зависимости от того, что вы нашли на первых двух шагах, этот шаг либо пройдет гладко, либо может занять некоторое время.

Как указывалось ранее, C++Builder и Visual C++ не согласны с тем, как должны называться функции в DLL. Из-за различий в соглашениях об именах вам потребуется создать библиотеку импорта с псевдонимами, если библиотека DLL реализует соглашения о вызовах, в которых C++Builder и Visual C++ расходятся. В таблице A перечислены области разногласий.

Таблица A: Соглашения об именах Visual C++ и C++Builder

Соглашение о вызовах Имя VC++ VC++ (используется DEF) Имя C++Builder
--------------- ---------------------------------------------------------
__stdcall _MyFunction@4 МояФункция МояФункция
__cdecl МояФункция МояФункция _МояФункция

В столбце C++Builder перечислены имена функций, которые компоновщик Borland ожидает увидеть. В первом столбце Visual C++ перечислены имена компоновщиков, которые создает Visual C++, когда проект Visual C++ не использует файл DEF. Второй столбец Visual C++ содержит имена компоновщиков, которые Visual C++ создает при использовании файла DEF. Чтобы все прошло гладко, имя C++Builder должно совпадать с именем Visual C++. Обратите внимание, что два продукта совпадают только в одном месте: функции __stdcall, где проект Visual C++ содержит файл DEF. Для остальных сценариев вам потребуется создать библиотеку импорта, в которой имя Visual C++ будет заменено на имя, совместимое с C++Builder.

Таблица A показывает, что существует несколько комбинаций, с которыми вам, возможно, придется иметь дело при создании библиотеки импорта. Я разделил комбинации на два случая.
Случай 1. DLL содержит только функции __stdcall, а поставщик DLL использовал файл DEF.

Таблица A показывает, что VC++ и C++Builder согласуются друг с другом только тогда, когда DLL использует функции __stdcall. Кроме того, DLL должна быть скомпилирована с файлом DEF, чтобы предотвратить изменение имен компоновщика средствами VC++. Заголовочный файл сообщит вам, использовалось ли соглашение о вызовах __stdcall (Шаг 1), а TDUMP покажет, оформлены ли функции (Шаг 2). Если библиотека DLL содержит недекорированные функции __stdcall, то Visual C++ и C++Builder согласовывают, как должны называться функции. Вы можете создать библиотеку импорта, запустив IMPLIB в DLL.Псевдонимы не нужны.

IMPLIB работает следующим образом:

IMPLIB (имя целевой библиотеки) (исходная dll)

IMPLIB mydll.lib mydll.dll

Создайте библиотеку импорта и перейдите к шагу 4.
Вариант 2: DLL содержит функции __cdecl или оформленные функции __stdcall.

Если ваш поставщик DLL непреклонен в отношении создания библиотек DLL, не зависящих от компилятора, у вас есть все шансы попасть в категорию "Случай 1". К сожалению, есть вероятность, что вы не попадете в группу Случая 1 по нескольким причинам. Во-первых, соглашение о вызовах по умолчанию равно __cdecl, если поставщик DLL опускает соглашение о вызовах при прототипировании функций, а __cdecl заставляет вас перейти к случаю 2. Во-вторых, даже если ваш поставщик использовал соглашение о вызовах __stdcall, он, вероятно, пренебрег использованием DEF. файл, чтобы удалить декорации Visual C++.

Как бы то ни было, добрый день, и добро пожаловать в случай 2. Вы застряли с библиотекой DLL, имена функций которой не согласуются с C++Builder. Единственный выход из этой неразберихи — создать библиотеку импорта, которая преобразует имена функций Visual C++ в формат, совместимый с C++Builder. К счастью, инструменты командной строки C++Builder позволяют создать библиотеку импорта с псевдонимом.

Первый шаг — создать файл DEF из библиотеки DLL Visual C++ с помощью программы IMPDEF, входящей в состав C++Builder. IMPDEF создает файл DEF, в котором перечислены все функции, экспортированные библиотекой DLL. Вы вызываете IMPDEF следующим образом:

IMPDEF (файл назначения DEF) (исходный файл DLL).

IMPDEF mydll.def mydll.dll

После запуска IMPDEF откройте полученный файл DEF с помощью редактора по вашему выбору. Когда исходный код DLL в листингах A и B скомпилирован с помощью Visual C++, файл DEF, созданный IMPDEF, выглядит следующим образом:

ЭКСПОРТ
CdeclFunction @1
UnknownFunction @3
_StdCallFunction@4 =_StdCallFunction @2

Следующий шаг — изменить файл DEF, чтобы он присвоил функциям DLL имена, которые понравятся C++Builder. Вы можете создать псевдоним для функции, указав имя, совместимое с C++Builder, за которым следует исходное имя компоновщика Visual C++. Для тестовой DLL в листингах A и B псевдоним DEF выглядит следующим образом:

ЭКСПОРТ
; используйте этот тип псевдонимов
; (Имя Borland) = (Имя, экспортированное Visual C++)
_CdeclFunction = CdeclFunction
_UnknownFunction = UnknownFunction
StdCallFunction = _StdCallFunction@4

Обратите внимание, что имена функций слева соответствуют именам, совместимым с Borland, из таблицы A. Имена функций справа — это фактические имена компоновщика функций в DLL Visual C++.

Последний шаг — создание библиотеки импорта с псевдонимом из файла DEF с псевдонимом. Вы снова полагаетесь на утилиту IMPLIB, за исключением того, что на этот раз вы передаете IMPLIB файл DEF с псевдонимом в качестве исходного файла вместо оригинальной DLL. Формат

IMPLIB (файл конечной библиотеки) (исходный файл def)

IMPLIB mydll.lib mydll.def

Создайте библиотеку импорта и перейдите к шагу 4. Вы можете сначала проверить библиотеку импорта, чтобы убедиться, что каждая функция DLL отображается в формате именования, с которым согласуется C++Builder. Вы можете использовать утилиту TLIB для проверки библиотеки импорта.

TLIB mydll.lib, mydll.lst

Файл списка для тестовой DLL выглядит следующим образом:

Паблики по модулю

StdCallFunction size = 0
StdCallFunction

_CdeclFunction size = 0
_CdeclFunction

_UnknownFunction size = 0
_UnknownFunction

Шаг 4. Добавьте библиотеку импорта в свой проект

После того как вы создадите библиотеку импорта для Visual C++ DLL, вы можете добавить библиотеку импорта в свой проект C++Builder, используя команду Project | Пункт меню «Добавить в проект». Вы используете библиотеку импорта независимо от того, содержит ли библиотека импорта псевдонимы или нет. После добавления библиотеки импорта в свой проект создайте проект и посмотрите, сможете ли вы успешно связать его.

В этой статье показано, как можно вызывать функции в DLL Visual C++ из проекта C++Builder. Методы работают с C++Builder 1 и C++Builder 3, а также с библиотеками DLL, созданными с помощью Visual C++ 4.X или Visual C++ 5 (я еще не тестировал Visual C++ 6).

Возможно, вы заметили, что в этой статье обсуждается только вызов функций стиля C в библиотеке DLL. Не предпринимается никаких попыток вызвать методы объекта, если код класса находится в библиотеке DLL Visual C++. Библиотеки C++ создают еще больший набор проблем, поскольку имена компоновщика для функций-членов искажаются. Компилятор использует схему изменения имени для поддержки перегрузки функций. К сожалению, стандарт C++ не указывает, как компилятор должен управлять методами класса. Не имея строгого стандарта, Borland и Microsoft разработали свои собственные методы искажения имен, и эти два соглашения несовместимы. Теоретически вы можете использовать ту же технику псевдонимов для вызова функций-членов класса, который находится в библиотеке DLL. Однако вместо этого вы можете рассмотреть возможность создания COM-объекта.COM создает множество собственных проблем, но при этом навязывает стандартный способ вызова методов объекта. COM-объект, созданный Visual C++, можно вызывать из любой среды разработки, включая Delphi и C++Builder.

Каким бы мощным ни был C++Builder, большинство библиотек DLL, разработанных и используемых в сообществе программистов, создаются с помощью Visual C++. Поэтому, скорее всего, вам потребуется связать код C++Builder с DLL Visual C++. Опять же, существует два способа подключения библиотеки DLL к приложению. Либо он может быть загружен динамически, либо он может быть загружен статически, если файл LIB, связанный с DLL, связан во время компиляции. Если этот файл LIB является файлом Microsoft LIB, DLL не сможет загрузиться. Причина в проблемах совместимости между форматом файла LIB для Visual C++ и C++Builder. Оба поставщика используют разные соглашения об экспорте. Microsoft поддерживает файл общего формата объектов (COFF), тогда как Borland использует формат объектной модели (OMF). К счастью, есть способ создать файл библиотеки импорта Borland OMF, который представляет собой библиотеку DLL, созданную Microsoft.

Чтобы создать совместимый с Borland файл .lib для библиотеки DLL Visual C++, можно использовать инструмент командной строки COFF2OMF от Borland, который находится в папке Bin в C++Builder. COFF2OMF принимает два аргумента: первый — это имя файла исходной библиотеки; а второе — имя файла назначения.

В этом примере COFF2OMF создаст новый файл библиотеки OMF с именем MyDll_bor.lib . В проекте C++Builder не забудьте связать этот файл MyDll_bor.lib как часть списка файлов проекта.

Утилита COFF2OMF работает только с файлами lib с простыми экспортированными функциями C. Если классы C++ экспортированы, это не сработает.

Если это не сработает, вам нужно выяснить, как функции экспортируются, и присвоить им псевдоним, который понравится C++Builder. Для этого сначала следует использовать Impdef.exe для создания файла определения (или файла .def), который позволяет просматривать имена и порядковые номера всех экспортируемых функций. номера . Затем измените экспортированные функции в файле .def, чтобы функция выглядела следующим образом:

После внесения изменений в библиотеку сохраните файл .def. Теперь вы можете использовать Implib.exe для этого файла, чтобы создать новый файл библиотеки, который понравится C++Builder. Implib.exe также принимает два параметра: место назначения и источник. Например

Поскольку теперь у вас есть библиотека в стиле C++Builder, вы сможете включить ее в свой проект и использовать DLL и .lib .


В этом руководстве описаны основные шаги по использованию библиотек динамической компоновки (DLL) в приложениях C++Builder (как в 32-разрядной, так и в 64-разрядной версии Windows).

Библиотека Dynamic-Link — это набор подпрограмм, которые можно загружать во время выполнения. Дополнительные сведения о библиотеках DLL см. в разделе Библиотеки и пакеты (Delphi).

Следующий пример содержит библиотеку DLL, которая экспортирует класс, описывающий стек целых чисел. Класс объявлен и реализован в проекте DLL. Целью этого примера является динамическая загрузка библиотеки DLL в приложении Firemonkey, а также импорт и использование стека целочисленного класса.

Чтобы экспортировать класс из DLL:

  1. Напишите заголовочный файл C++, объявляющий виртуальный базовый класс для стека. Этот виртуальный базовый класс должен содержать методы экспортируемого класса. Этот заголовочный файл будет включен в проект, в который импортируется класс из библиотеки DLL.
  2. Объявите и реализуйте класс, производный от виртуального класса стека. Здесь реализованы методы стека. В следующем руководстве для стека будет использоваться целочисленная реализация.
  3. Реализуйте и экспортируйте метод, возвращающий экземпляр стека целочисленного класса. Этот метод будет использоваться для получения экземпляра класса, объявленного в проекте DLL.

Содержание

Шаги и исходный код

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

Учебник состоит из двух основных проектов:

  • StackLibrary.dll — это проект DLL. Здесь объявляется и реализуется стек целых чисел. Кроме того, этот проект содержит метод, используемый для получения экземпляра класса стека. Этот метод экспортируется из библиотеки DLL.
  • TestStackLibrary — это приложение FireMonkey. В этом проекте загружается ранее объявленная DLL и импортируется открытый метод. После вызова этого метода извлекается экземпляр класса стека. В этом проекте тестируются методы класса стека.

Вот шаги для создания двух проектов:

Динамическая библиотека

  1. Выберите «Файл» > «Создать» > «Другое» > «Проекты C++Builder» > «Библиотека динамической компоновки» и нажмите «ОК».
  2. В открывшемся диалоговом окне "Новая динамическая библиотека" выберите Firemonkey в качестве целевой платформы и нажмите "ОК".

Примечание: эта DLL не будет использовать какую-либо структуру, даже если приложение, которое будет загружать DLL, является приложением Firemonkey.

  1. Назовите файл C++ в проекте DLL StackExport.cpp.
  2. Назовите предварительно скомпилированный заголовочный файл StackLibraryPCH1.h.
  3. Назовите проект DLL StackLibrary.
  • BaseStack.h содержит определение виртуального базового класса для стека. Этот класс используется как в DLL, так и в проекте Firemonkey.
  • StackOfInt.h содержит объявление класса Stack. Stack является потомком BaseStack, который описывает стек целых чисел.
  • StackOfInt.cpp содержит реализацию класса Stack.

Базовый стек.h

BaseStack — это виртуальный базовый класс для Stack (объявлен в StackOfInt.h). Поэтому для его методов не требуется реализация.

StackOfInt.h

Этот файл объявляет класс Stack. Stack описывает стек целых чисел и объявляет его методы: Push, Pop, Top и IsEmpty.

StackOfInt.cpp

StackExport.cpp

Этот файл экспортирует функцию GetClassInstance. Эта функция возвращает экземпляр Stack .

Приложение Firemonkey

  1. Щелкните правой кнопкой мыши группу проектов в Диспетчере проектов и выберите Добавить новую >Форма для нескольких устройств — C++Builder.
  2. Выберите «Файл» > «Сохранить все» и задайте имена созданных файлов следующим образом:
    1. Назовите проект Firemonkey TestStackLibrary.
    2. Назовите модуль C++ в проекте Firemonkey TestUnit.

    Примечание. В приведенном ниже исходном коде предполагается, что вы сохраняете эти файлы в той же папке, в которой вы сохранили файлы библиотеки.

    StackForm.jpg

    1. Добавьте пять элементов управления TButton. Назовите их следующим образом и установите соответствующие метки:
      • Кнопка загрузки
      • Кнопка
      • Верхняя кнопка
      • Всплывающая кнопка
      • IsEmptyButton
    2. Для каждой кнопки добавьте обработчик события OnClick. Вы можете добавить код для обработчиков событий позже.
    3. Добавьте один элемент управления TEdit. Вот как должна выглядеть форма Firemonkey:
    • BaseStack* stack для хранения экземпляра стека.
    • void __fastcall EnableButtons() .

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


    RAD Studio обеспечивает поддержку библиотек Dynamic-Link как для Windows (файлы DLL), так и для macOS (файлы dylib).

    Чтобы создать динамическую библиотеку, выберите «Файл» > «Создать» > «Другое». В узле "Проекты C++Builder" выберите "Библиотека динамической компоновки".

    Следующий код будет автоматически сгенерирован в основном файле вновь созданного проекта:

    Функция _libmain — это точка входа в динамическую библиотеку. При загрузке динамической библиотеки вызывается функция _libmain. Эта функция обычно содержит код инициализации.

    Содержание

    Экспорт функций

    Функции, определенные в динамической библиотеке, должны быть экспортированы, чтобы их можно было увидеть за пределами динамической библиотеки. Это синтаксис для экспорта функций:

    Импорт функций

    Чтобы использовать функции, определенные в динамической библиотеке, вы должны объявить функцию как импортированную, загрузить библиотеку, в которой определена функция, а затем получить доступ к функции. Это синтаксис для импорта функций:

    Примечание. Импортированный прототип функции должен соответствовать определению функции в динамической библиотеке.

    Использование библиотеки динамической компоновки

    Для вызова функций, экспортированных библиотекой динамической компоновки, библиотека должна быть загружена в память, а функция должна быть объявлена ​​как импортированная функция. Существует два способа загрузки библиотеки: статически (во время компоновки) и динамически (во время выполнения).

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

    При ориентации на Win32 и Win64 вы можете добавить библиотеку импорта в свой проект из кода, вставив следующую директиву pragma в исходный файл проекта:


    При ориентации на Win32 процедура требует привязки библиотеки динамической компоновки через библиотеку импорта с расширением .lib. При ориентации на Win64 процедура требует привязки библиотеки динамической компоновки через библиотеку импорта с расширением .a. Библиотека импорта автоматически создается проектом библиотеки динамической компоновки.

    Если вы ориентируетесь только на WIN32 или только на WIN64, вместо прагмы вы можете добавить библиотеку импорта в свой проект, щелкнув проект правой кнопкой мыши в окне "Проекты" и выбрав "Добавить". . После добавления библиотеки импорта в ваш проект убедитесь, что функции были импортированы (используйте синтаксис импорта, описанный выше). Теперь эти функции можно использовать в вашем проекте.

    Примечание. Убедитесь, что в проекте библиотеки динамической компоновки для параметра «Создать библиотеку импорта» установлено значение «Истина», чтобы библиотека импорта (файл .lib) создавалась при сборке проекта. Дополнительные сведения см. в разделе Компоновщик C++.

    Динамическая загрузка библиотеки

    После объявления импортированных функций динамическая библиотека должна быть загружена во время выполнения. Эта операция выполняется с помощью функции LoadLibrary. Когда библиотека загружена в память, используйте функцию GetProcAddress для получения указателя на определенную функцию.

    Вот полный пример использования динамических библиотек в приложениях C++Builder: Учебное пособие: использование динамических связанных библиотек в приложениях C++Builder.

    Читайте также: