cpp編譯動態鏈接庫

❶ C語言怎麼使用動態鏈接庫，如何創建（高手進）

C程序編譯成dll文件只不過是在要公開的介面函數聲明前面加上幾個特定的修飾符而已。用dev-cpp建了個dll的默認文檔，一切都很明了。（我把源代碼貼在下面）

/*dll.h文件*/

#ifndef _DLL_H_
#define _DLL_H_

#if BUILDING_DLL
# define DLLIMPORT __declspec (dllexport)
#else /* Not BUILDING_DLL */
# define DLLIMPORT __declspec (dllimport)
#endif /* Not BUILDING_DLL */

DLLIMPORT void HelloWorld (void);

#endif /* _DLL_H_ */

/*dllmain.c文件*/

/* Replace "dll.h" with the name of your header */
#include "dll.h"
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>

DLLIMPORT void HelloWorld ()
{
MessageBox (0, "Hello World from DLL!\n", "Hi", MB_ICONINFORMATION);
}

BOOL APIENTRY DllMain (HINSTANCE hInst /* Library instance handle. */ ,
DWORD reason /* Reason this function is being called. */ ,
LPVOID reserved /* Not used. */ )
{
switch (reason)
{
case DLL_PROCESS_ATTACH:
break;

case DLL_PROCESS_DETACH:
break;

case DLL_THREAD_ATTACH:
break;

case DLL_THREAD_DETACH:
break;
}

/* Returns TRUE on success, FALSE on failure */
return TRUE;
}

關於以上代碼的幾點解釋：
一、__declspec (dllexport)：這是關鍵，它標志著這個這個函數將成為對外的介面。（以下是我在網上下載的dllexport、dllimport、_declspec的一些說明）：
使用包含在DLL的函數，必須將其導入。導入操作時通過dllimport來完成的，dllexport和dllimport都是vc（visual C++）和bc（Borland C++）所支持的擴展的關鍵字。但是dllexport和dllimport關鍵字不能被自身所使用，因此它的前面必須有另一個擴展關鍵字__declspec。通用格式如下：__declspec(specifier)其中specifier是存儲類標示符。對於DLL，specifier將是dllexport和dllimport。而且為了簡化說明導入和導出函數的語句，用一個宏名來代替__declspec.在此程序中，使用的是DllExport。如果用戶的DLL被編譯成一個C++程序，而且希望C程序也能使用它，就需要增加「C」的連接說明。#define DllExport extern "C"__declspec(dllexport)，這樣就避免了標准C++命名損壞。（當然，如果讀者正在編譯的是C程序，就不要加入extern 「C」,因為不需要它，而且編譯器也不接受它）。

二、BOOL APIENTRY DllMain ()說明：（以下是我在網上收集的資料）

1、每一個DLL必須有一個入口點，DllMain是一個預設的入口函數。DllMain負責初始化(Initialization)和結束(Termination)工作，每當一個新的進程或者該進程的新的線程訪問DLL時，或者訪問DLL的每一個進程或者線程不再使用DLL或者結束時，都會調用DllMain。但是，使用TerminateProcess或TerminateThread結束進程或者線程，不會調用DllMain。
DllMain的函數原型：
BOOL APIENTRY DllMain(HANDLE hMole,DWORD ul_reason_for_call,LPVOID lpReserved)
{
switch(ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
.......
case DLL_THREAD_ATTACH:
.......
case DLL_THREAD_DETACH:
.......
case DLL_PROCESS_DETACH:
.......
return TRUE;
}
}

參數：
hMoudle：是動態庫被調用時所傳遞來的一個指向自己的句柄(實際上，它是指向_DGROUP段的一個選擇符)；
ul_reason_for_call：是一個說明動態庫被調原因的標志。當進程或線程裝入或卸載動態連接庫的時候，操作系統調用入口函數，並說明動態連接庫被調用的原因。它所有的可能值為：
DLL_PROCESS_ATTACH: 進程被調用；
DLL_THREAD_ATTACH: 線程被調用；
DLL_PROCESS_DETACH: 進程被停止；
DLL_THREAD_DETACH: 線程被停止；
lpReserved：是一個被系統所保留的參數。

看到這里，我想大家應該會對將c程序編譯成dll文件有了個大體的概念。

關於對於dll文件的使用，我在vb.net里做了以下測試：
首先用vs.net 2003新建一個vb.net應用程序。
然後在工程屬性中引用System.Runtime.InteropServices命名空間。
然後在默認的窗體文件中添加如下代碼：
Public Class Form1
Inherits System.Windows.Forms.Form

#Region " Windows 窗體設計器生成的代碼 "

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

End Sub

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Hello()
End Sub
End Class

Mole test
Sub main()
Dim frm As New Form1
Application.Run(frm)

End Sub
<DllImport("test.dll", EntryPoint:="HelloWorld", setlasterror:=True)> Public Sub Hello()

End Sub
End Mole

然後把上面用devcpp生成的test.dll放入工程bin目錄下，測試成功。

關於dll文件的一點設想：
關於多語言創建dll文件和動態使用dll文件，我感覺應該是插件技術plugin技術最直接的實現方式。特別是現在的.net平台，為動態導入dll文件中的函數提供了更簡易的方法。一個實現插件的基本思想可以是，在主程序和插件程序內做出一個規定的通訊方式，比如將一個可以代表使用插件功能的對象，由主程序創建對應插件程序的對象，然後由插件程序傳址調用，調用修改後的對象中保存了插件功能信息（比如插件名稱、功能函數指針等），然後再由主程序進行處理。

以下是網上摘抄的一點資料：

動態鏈接庫中定義有兩種函數：導出函數(export function)和內部函數(internal function)。導出函數可以被其它模塊調用，內部函數在定義它們的DLL程序內部使用。

輸出函數的方法有以下幾種：

1、傳統的方法

在模塊定義文件的EXPORT部分指定要輸入的函數或者變數。語法格式如下：
entryname[=internalname] [@ordinal[NONAME]] [DATA] [PRIVATE]

其中：

entryname是輸出的函數或者數據被引用的名稱；

internalname同entryname;

@ordinal表示在輸出表中的順序號(index)；

NONAME僅僅在按順序號輸出時被使用（不使用entryname）；

DATA表示輸出的是數據項，使用DLL輸出數據的程序必須聲明該數據項為_declspec(dllimport)。

上述各項中，只有entryname項是必須的，其他可以省略。

對於「C」函數來說，entryname可以等同於函數名；但是對「C++」函數（成員函數、非成員函數）來說，entryname是修飾名。可以從.map映像文件中得到要輸出函數的修飾名，或者使用DUMPBIN /SYMBOLS得到，然後把它們寫在.def文件的輸出模塊。DUMPBIN是VC提供的一個工具。

如果要輸出一個「C++」類，則把要輸出的數據和成員的修飾名都寫入.def模塊定義文件。

2、在命令行輸出

對鏈接程序LINK指定/EXPORT命令行參數，輸出有關函數。

3、使用MFC提供的修飾符號_declspec(dllexport)

在要輸出的函數、類、數據的聲明前加上_declspec(dllexport)的修飾符，表示輸出。__declspec(dllexport)在C調用約定、C編譯情況下可以去掉輸出函數名的下劃線前綴。extern "C"使得在C++中使用C編譯方式成為可能。在「C++」下定義「C」函數，需要加extern 「C」關鍵詞。用extern "C"來指明該函數使用C編譯方式。輸出的「C」函數可以從「C」代碼里調用。

例如，在一個C++文件中，有如下函數：
extern "C" {void __declspec(dllexport) __cdecl Test(int var);}
其輸出函數名為：Test

MFC提供了一些宏，就有這樣的作用。

AFX_CLASS_IMPORT：__declspec(dllexport)

AFX_API_IMPORT：__declspec(dllexport)

AFX_DATA_IMPORT：__declspec(dllexport)

AFX_CLASS_EXPORT：__declspec(dllexport)

AFX_API_EXPORT：__declspec(dllexport)

AFX_DATA_EXPORT：__declspec(dllexport)

AFX_EXT_CLASS： #ifdef _AFXEXT
AFX_CLASS_EXPORT
#else
AFX_CLASS_IMPORT

AFX_EXT_API：#ifdef _AFXEXT
AFX_API_EXPORT
#else
AFX_API_IMPORT

AFX_EXT_DATA：#ifdef _AFXEXT
AFX_DATA_EXPORT
#else
AFX_DATA_IMPORT

像AFX_EXT_CLASS這樣的宏，如果用於DLL應用程序的實現中，則表示輸出（因為_AFX_EXT被定義，通常是在編譯器的標識參數中指定該選項/D_AFX_EXT）；如果用於使用DLL的應用程序中，則表示輸入（_AFX_EXT沒有定義）。

要輸出整個的類，對類使用_declspec(_dllexpot)；要輸出類的成員函數，則對該函數使用_declspec(_dllexport)。如：

class AFX_EXT_CLASS CTextDoc : public CDocument
{
…
}

extern "C" AFX_EXT_API void WINAPI InitMYDLL();

這幾種方法中，最好採用第三種，方便好用；其次是第一種，如果按順序號輸出，調用效率會高些；最次是第二種。

❷ C#中如何使用頭文件(xxxx.h),以及如何將頭文件編譯成動態鏈接庫(DLL)

頭文件、cpp文件和dll文件之間的是這樣的關系：頭文件聲明方法，cpp實現方法、cpp編譯後得到dll，因此頭文件描述的是dll文件的介面，也就是具體實現的介面。如果你只有dll文件，只要知道其導出的方法就可以直接使用，win32有對應的api。如果想要將dll中的所有可用方法包含到項目中，就要包含頭文件。這就是說，頭文件和dll文件是對應的。另外，如果你的頭文件中已經包含了實現代碼，那你需要提供一個空的cpp文件，包含該頭文件，並將它們編譯成dll文件。
C#沒法直接用C++的頭文件，但是可以直接用dll，使用的技術稱作PInvoke，原理是在C#代碼中用extern關鍵字添加dll中所需方法的簽名，也就是二樓說的那種方法。此外，如果這個dll是採用com技術實現的，也可以使用.NET平台提供的COM互操作特性直接導入使用。

❸ VC6.0如何創建以及調用動態鏈接庫實例詳解

動態鏈接庫：dll不必被包含在最終的EXE中，EXE文件執行時可以動態地引用和卸載DLL文件。
同時，靜態鏈接庫中不能再包含其他的動態鏈接庫或靜態庫，而動態鏈接庫中可以包含其他的動態或靜態庫。
VC++支持的DLL：
DLL的編制與具體的編程語言及編譯器無關，動態鏈接庫隨處可見，VC++支持三種DLL：非MFC動態庫、MFC規則DLL和MFC擴展DLL。DLL導出函數（或變數、類）可供應用程序調用；DLL內部函數只能在DLL程序內使用，應用程序無法調用它們。
導出函數的聲明方式：
一種在函數聲明類型和函數名之間加上「_declspec(dllexport)」。
另外一種採用模塊定義（.def）文件聲明，需要在庫工程中添加模塊文件，格式如下：
LIBRARY 庫工程名稱
EXPORTS 導出函數名
DLL的調用方式：
一種靜態調用，由編譯系統完成對DLL的載入和應用程序結束時DLL的卸載。
另外一種動態調用，由編程者用API函數載入和卸載DLL（DLL載入—DLL函數地址獲取—DLL釋放）方式。
所有庫工程編譯時必須Release方式：
Build—set active configuration—選擇庫工程的release方式
一、 函數----創建動態鏈接庫（MFC規則DLL）
1. New--projects--MFC AppWizard(dll)--Regular DLL using shared MFC DLL //取名為MFC_dll
2. def文件中添加：函數名（Add_new）
3. h文件中添加：外部函數聲明//求和函數，函數名為Add_new
extern "C" __declspec(dllexport) int __stdcall Add_new(int a,int b);
4. cpp文件中添加： 外部函數實現
extern "C" __declspec(dllexport) int __stdcall Add_new(int a,int b)
{
return a+b;
}
5. build--set active configuration--win32 release--ok
6. 生成
7. 根目錄下release文件夾中dll,lib與根目錄下h文件即為所需
二、 函數----調用動態鏈接庫（把MFC_dll.dll和MFC_dll.lib拷到工程所在目錄）
//靜態調用（.h可以寫到.cpp文件中）
1. new--projects--win32 console application--an empty project
2. 添加h文件：(test.h)
#pragma comment(lib,"MFC_dll.lib") //告訴編譯器DLL相對應的lib文件所在路徑和文件名
extern "C" _declspec(dllimport) int _stdcall Add_new(int a,int b);//聲明導入函數
3. 添加cpp文件：(main.cpp)
#include "test.h"
int main()
{
cout<<Add_new(10,3);
return 0;
}
//動態調用
#include <stdio.h>
#include <windows.h>
typedef int (* lpAddFun)(int ,int);//定義一個與Add_new函數接受參數類型和返回值均相同的函數指針類型
int main()
{
HINSTANCE hDll;//句柄
lpAddFun addFun;//函數指針
hDll=LoadLibrary("dllTest.dll");//動態載入DLL模塊句柄
if(hDll)
{
addFun=(lpAddFun) GetProcAddress(hDll,"Add_new");//得到所載入DLL模塊中函數的地址
if(addFun)
{
int result=addFun(2,3);
printf("%d",result); } FreeLibrary(hDll);//釋放已經載入的DLL模塊
}
return 0;
}
三、 變數----創建動態鏈接庫（非MFC DLL）
1. new---projects---win32 dynamic-link library----an empty project(Sample)
2. 添加sample.h
#ifndef SAMPLE_H
#define SAMPLE_H
extern int dllGlobalVar;
#endif
3. 添加 sample.cpp
#include "sample.h"
#include <windows.h>
int dllGlobalVar;
bool APIENTRY DllMain(HANDLE hMole,DWORD ul_reason_for_call,LPVOID lpReserved)
//windows在載入DLL時，需要一個入口函數，就如同控制台或DOS程序需要main函數、win32程序需要winmain函數一樣。所以引入一個不做任何操作的預設DllMain的函數版本。是DLL的內部函數。

❹ 怎樣將C++寫的工程做成動態鏈接庫

//Utility.h
#pragmaonce
#include<string>
#include<vector>

#ifdefUTILITY_EXPORTS
#defineUTILITY_API__declspec(dllexport)
#else
#defineUTILITY_API__declspec(dllimport)
#endif

#include"stdafx.h"
#include<assert.h>
#ifdef_DEBUG
#defineDEBUG_CLIENTBLOCKnew(_CLIENT_BLOCK,__FILE__,__LINE__)
#else
#defineDEBUG_CLIENTBLOCK
#endif
#define_CRTDBG_MAP_ALLOC
#include<crtdbg.h>
#ifdef_DEBUG
#definenewDEBUG_CLIENTBLOCK
#endif

//Entry.cpp:定義DLL應用程序的入口點。
//

#include"stdafx.h"

#ifdef_MANAGED
#pragmamanaged(push,off)
#endif

BOOLAPIENTRYDllMain(HMODULEhMole,
					DWORDul_reason_for_call,
					LPVOIDlpReserved
					)
{
	returnTRUE;
}

#ifdef_MANAGED
#pragmamanaged(pop)
#endif

上面的頭文件和源碼是來自我的一個通用項目 Utitliy，其他的 cpp 引用 Utitliy.h 頭文件即可， 當然你要設置輸出成 dll。

❺ C++能不能把類寫成動態鏈接庫

可以，dll只是一種文件類型而已，只不過不能獨自運行，裡面寫什麼東西都行，不明白你為什麼會有這樣的疑問。
實例化的話如果庫已經載入了，載入就是項目屬性裡面把庫填進去就行了（如果是vs環境）。直接引用一下庫的頭文件然後創建對象就可以了。這根本不算個問題啊，你是不是想問動態庫的運行原理呢。

❻ c++動態鏈接的聲明和實現函數 怎麼做成動態鏈接庫

動態鏈接庫的使用方法，動態鏈接庫的動態調用（也叫顯式調用）可以運用了，但是靜態調用（也叫隱式調用）這種很少見。

（一）先回顧一下，動態鏈接庫和靜態鏈接庫
靜態鏈接庫：lib中的函數不僅被連接，全部實現都被直接包含在最終生成的EXE文件中，只是實現是不可見的。
動態鏈接庫：dll不必被包含在最終的EXE中，靜態調用時僅把函數名或者變數名或者類名鏈接到EXE文件中，而這些東西的實體都只有在運行時才從動態庫中導入到可執行文件中，動態調用的時候EXE文件執行時可以直接動態地引用和卸載DLL文件。
同時，靜態鏈接庫中不能再包含其他的動態鏈接庫或靜態庫，而動態鏈接庫中可以包含其他的動態或靜態庫。

（二）回顧一下VC++支持的DLL：
DLL的編制與具體的編程語言及編譯器無關，動態鏈接庫隨處可見，VC++支持三種DLL：非MFC動態庫、MFC規則DLL和MFC擴展DLL。DLL導出函數（或變數、類）可供應用程序調用；DLL內部函數只能在DLL程序內使用，應用程序無法調用它們。

（三）導出函數的聲明方式：
一種在函數聲明類型和函數名之間加上「_declspec(dllexport)」。
另外一種採用模塊定義（.def）文件聲明，需要在庫工程中添加模塊文件，格式如下：
LIBRARY 庫工程名稱
EXPORTS 導出函數名

（四）DLL的調用方式：
靜態調用中，由編譯系統完成對DLL的載入和應用程序結束時DLL的卸載。
動態調用中，由編程者用API函數載入和卸載DLL（DLL載入—DLL函數地址獲取—DLL釋放）方式。

接下來寫個例子把上面提到的理論都實踐一遍。

一、 函數----創建動態鏈接庫（MFC規則DLL）
1. New--projects--MFC AppWizard(dll)--Regular DLL using shared MFC DLL //取名為MFC_dll
2. def文件中添加：函數名（Add_new）
3. h文件中添加：外部函數聲明//求和函數，函數名為Add_new
extern "C" __declspec(dllexport) int __stdcall Add_new(int a,int b);
4. cpp文件中添加： 外部函數實現
extern "C" __declspec(dllexport) int __stdcall Add_new(int a,int b)
{
return a+b;
}
5. build--set active configuration--win32 release--ok
6. 生成
7. 根目錄下release文件夾中dll,lib與根目錄下h文件即為所需

二、 函數----調用動態鏈接庫（把MFC_dll.dll和MFC_dll.lib拷到工程所在目錄）
//靜態調用（.h可以寫到.cpp文件中）
1. new--projects--win32 console application--an empty project
2. 添加h文件：(test.h)
#pragma comment(lib,"MFC_dll.lib") //告訴編譯器DLL相對應的lib文件所在路徑和文件名
extern "C" _declspec(dllimport) int _stdcall Add_new(int a,int b);//聲明導入函數
3. 添加cpp文件：(main.cpp)
#include "test.h"
int main()
{
cout<<Add_new(10,3);
return 0;
}
//動態調用
#include <stdio.h>
#include <windows.h>
typedef int (* lpAddFun)(int ,int);//定義一個與Add_new函數接受參數類型和返回值均相同的函數指針類型
int main()
{
HINSTANCE hDll;//句柄
lpAddFun addFun;//函數指針
hDll=LoadLibrary("dllTest.dll");//動態載入DLL模塊句柄
if(hDll)
{
addFun=(lpAddFun) GetProcAddress(hDll,"Add_new");//得到所載入DLL模塊中函數的地址
if(addFun)
{
int result=addFun(2,3);
printf("%d",result); } FreeLibrary(hDll);//釋放已經載入的DLL模塊
}
return 0;
}

三、 變數----創建動態鏈接庫（非MFC DLL）
1. new---projects---win32 dynamic-link library----an empty project(Sample)
2. 添加sample.h
#ifndef SAMPLE_H
#define SAMPLE_H
extern int dllGlobalVar;
#endif
3. 添加 sample.cpp
#include "sample.h"
#include <windows.h>
int dllGlobalVar;
bool APIENTRY DllMain(HANDLE hMole,DWORD ul_reason_for_call,LPVOID lpReserved)
//windows在載入DLL時，需要一個入口函數，就如同控制台或DOS程序需要main函數、win32程序需要winmain函數一樣。所以引入一個不做任何操作的預設DllMain的函數版本。是DLL的內部函數。


有一點要注意，如果看到此類宏定義
#ifdef KSCANBAR_EXPORTS
#define KSCANBAR_API __declspec(dllexport)
#else
#define KSCANBAR_API __declspec(dllimport)
#endif
是因為這樣定義一般出現在含有多個項目的解決方案中，這樣可以使從 DLL 導出更簡單的宏的標准方法。此 DLL 中的所有文件都是用命令行上定義的 KSCANBAR_EXPORTS符號編譯的。在使用此 DLL 的任何其他項目上不應定義此符號。這樣，源文件中包含此文件的任何其他項目都會將KSCANBAR_API 函數視為是從 DLL 導入的，而此 DLL 則將用此宏定義的符號視為是被導出的。

❼ 動態鏈接庫和靜態鏈接庫的區別

一、指代不同

1、動態鏈接庫：是微軟公司在微軟Windows操作系統中，實現共享函數庫概念的一種方式。

2、靜態鏈接庫：函數和數據被編譯進一個二進制文件（通常擴展名為*.LIB），Visual C++的編譯器在鏈接過程中將從靜態庫中恢復這些函數和數據並把他們和應用程序中的其他模塊組合在一起生成可執行文件。

二、特點不同

1、動態鏈接庫：庫函數的擴展名是 」.dll"、".ocx"（包含ActiveX控制的庫）或者 ".drv"（舊式的系統驅動程序）。

2、靜態鏈接庫：使用的.lib文件，庫中的代碼最後需要連接到可執行文件中去。

三、調用方法不同

1、動態鏈接庫：提供了一種使進程可以調用不屬於其可執行代碼的函數。函數的可執行代碼位於一個 DLL 文件中，該 DLL 包含一個或多個已被編譯、鏈接並與使用它們的進程分開存儲的函數。

2、靜態鏈接庫：用程序所需的全部內容都是從庫中復制了出來，所以靜態庫本身並不需要與可執行文件一起發行。

❽ cpp文件是怎麼變成可執行文件的動態鏈接庫又是什麼呢

=
=...以下是個人理解....我也是菜鳥一隻
1、cpp經過編譯、鏈接生成了.exe。詳細過程請看《編譯原理》之類的書。
2、qt圖形庫應該類似mfc，是.dll導出的，包括頭文件之後使用。
3、makefile相當於安裝文件，=
=，貌似...這個我沒用過。
4、類似mfc，qt的函數是由qt的某個dll導出的。dll就是動態鏈接庫。動態鏈接庫是在運行時動態鏈接到進程中的，而靜態鏈接庫是在鏈接時直接加到了程序文件中的。所以靜態鏈接生成的文件要比動態鏈接的大。

❾ 如何用c語言調用c++做成的動態鏈接庫

因為c++的各種復雜機制，生成的動態鏈接庫中的符號名是不符合C的機制的，直接鏈接會失敗，一般解決c和c++的鏈接問題是在c++的代碼上進行處理的，只要將你的cpp文件中的函數定義都加上extern "c"前綴，就可以編譯成C可鏈接的庫。如果你只有cpp的庫文件，沒有源碼文件的話，沒法處理。

//a.cpp
extern"C"intcpp_func(){return0;}

//b.c
#include<stdio.h>
intcpp_func();

intmain(){
printf("%d
",cpp_func());
return0;
}

//***compileandlink***
//g++a.cpp-oa.o
//gccb.c-ob.o
//g++a.ob.o-oa.out&&./a.out