當前位置:首頁 » 編程軟體 » 動態庫編譯器

動態庫編譯器

發布時間: 2022-04-19 06:01:56

linux 下如何將動態鏈接庫.so進行反編譯後,換編譯器重新編譯

程序能不能正常運行取決於程序和動態庫之間的ABI是否兼容。只要ABI兼容那麼編譯器版本就沒有影響。高版本的編譯器同樣可以使用低版本的ABI來生成目標代碼,但這個問題要具體分析。你解決問題的思路完全不對。

Ⅱ 關於動態庫 靜態庫 區別與使用 路徑查找等

一、引言

我們通常把一些公用函數製作成函數庫,供其它程序使用。
函數庫分為靜態庫和動態庫兩種。

通常情況下,對函數庫的鏈接是放在編譯時期(compile time)完成的。所有相關的對象文件(object file)與牽涉到的函數庫(library)被鏈接合成一個可執行文件(executable file)。程序在運行時,與函數庫再無瓜葛,因為所有需要的函數已拷貝到相應目錄下下。所以這些函數庫被成為靜態庫(static libaray),通常文件名為「libxxx.a」的形式。

其實,我們也可以把對一些庫函數的鏈接載入推遲到程序運行的時期(runtime)。這就是動態鏈接庫(dynamic link library)技術。

二、兩者區別:
a,靜態庫的使用需要:
1 包含一個對應的頭文件告知編譯器lib文件裡面的具體內容
2 設置lib文件允許編譯器去查找已經編譯好的二進制代碼

b,動態庫的使用:
程序運行時需要載入動態庫,對動態庫有依賴性,需要手動加入動態庫

c,依賴性:
靜態鏈接表示靜態性,在編譯鏈接之後, lib庫中需要的資源已經在可執行程序中了, 也就是靜態存在,沒有依賴性了
動態,就是實時性,在運行的時候載入需要的資源,那麼必須在運行的時候提供 需要的 動態庫,有依賴性, 運行時候沒有找到庫就不能運行了

d,區別:
簡單講,靜態庫就是直接將需要的代碼連接進可執行程序;動態庫就是在需要調用其中的函數時,根據函數映射表找到該函數然後調入堆棧執行。
做成靜態庫可執行文件本身比較大,但不必附帶動態庫
做成動態庫可執行文件本身比較小,但需要附帶動態庫
鏈接靜態庫,編譯的可執行文件比較大,當然可以用strip命令精簡一下(如:strip libtest.a),但還是要比鏈接動態庫的可執行文件大。程序運行時間速度稍微快一點。
靜態庫是程序運行的時候已經調入內存,不管有沒有調用,都會在內存里頭。靜態庫在程序編譯時會被連接到目標代碼中,程序運行時將不再需要該靜態庫。
其在編譯程序時若鏈接,程序運行時會在系統指定的路徑下搜索,然後導入內存,程序一般執行時間稍微長一點,但編譯的可執行文件比較小;動態庫是程序運行的時候需要調用的時候才裝入內存,不需要的時候是不會裝入內存的。
動態庫在程序編譯時並不會被連接到目標代碼中,而是在程序運行是才被載入,因此在程序運行時還需要動態庫存在。

三、動態鏈接庫的特點與優勢

首先讓我們來看一下,把庫函數推遲到程序運行時期載入的好處:

1. 可以實現進程之間的資源共享。

什麼概念呢?就是說,某個程序的在運行中要調用某個動態鏈接庫函數的時候,操作系統首先會查看所有正在運行的程序,看在內存里是否已有此庫函數的拷貝了。如果有,則讓其共享那一個拷貝;只有沒有才鏈接載入。這樣的模式雖然會帶來一些「動態鏈接」額外的開銷,卻大大的節省了系統的內存資源。C的標准庫就是動態鏈接庫,也就是說系統中所有運行的程序共享著同一個C標准庫的代碼段。

2. 將一些程序升級變得簡單。用戶只需要升級動態鏈接庫,而無需重新編譯鏈接其他原有的代碼就可以完成整個程序的升級。Windows 就是一個很好的例子。

3. 甚至可以真正坐到鏈接載入完全由程序員在程序代碼中控制。

程序員在編寫程序的時候,可以明確的指明什麼時候或者什麼情況下,鏈接載入哪個動態鏈接庫函數。你可以有一個相當大的軟體,但每次運行的時候,由於不同的操作需求,只有一小部分程序被載入內存。所有的函數本著「有需求才調入」的原則,於是大大節省了系統資源。比如現在的軟體通常都能打開若干種不同類型的文件,這些讀寫操作通常都用動態鏈接庫來實現。在一次運行當中,一般只有一種類型的文件將會被打開。所以直到程序知道文件的類型以後再載入相應的讀寫函數,而不是一開始就將所有的讀寫函數都載入,然後才發覺在整個程序中根本沒有用到它們。

靜態庫:在編譯的時候載入生成目標文件,在運行時不用載入庫,在運行時對庫沒有依賴性。
動態庫:在目標文件運行時載入,手動載入,且對庫有依賴性。

具體在開發中用到哪種庫,我覺得還是根據實際的內存大小,ROM大小,運行的速度等綜合考慮。

Ⅲ 動態庫 是什麼

首先,想要知道動態庫,我們得了解C++/C以及計算機的一些背景知識。
一般而言,在Windows下,*.dll文件就是動態庫文件。用C++/C開發的程序,在發布的時候,會出現兩種情況,第一,整個軟體就只有一個文件,你只要雙擊那個exe文件,就可以運行。第二,除了exe之外,還有dll等文件。在這里,我們假設的文件只有exe文件和dll文件, 不討論什麼圖標之類文件。
只有一個文件的,庫已經嵌到那個exe裡面。而有很多dll文件的程序,庫沒有嵌入到exe裡面。所以,你可以看一下,如果那個exe文件大小非常大,那就說明是靜態鏈接,在開發的時候是使用靜態庫。如果那個exe非常小,那麼一般是使用的動態庫。
那麼問題來了,動態庫與靜態庫相比優勢又是什麼。動態庫節約內存,為什麼這么說呢。假如兩個類型的程序,如果他們都有一個共同使用的dll,那麼在內存裡面,只有一份,而不是兩份。如果是使用了靜態庫,這會有兩份,會有很大的浪費空間。
當然,使用動態庫還有需要注意的地方。比如,有兩個名字一模一樣的動態庫Qtcore4.dll,但是呢,一個dll是用vs2010編譯器生成的,一個是用vs2015編譯器生成的。如果,exe使用的dll弄錯的話,程序結果會不對或者其他奇葩的問題。
以上均是一個大致的講解,細節部分請參考程序員的自我修養這本書!

Ⅳ linux 靜態庫和動態庫編譯的區別

Linux庫有動態與靜態兩種,動態通常用.so為後綴,靜態用.a為後綴。例如:libhello.so libhello.a
為了在同一系統中使用不同版本的庫,可以在庫文件名後加上版本號為後綴,例如: libhello.so.1.0,由於程序連接默認以.so為文件後綴名。所以為了使用這些庫,通常使用建立符號連接的方式。
ln -s libhello.so.1.0 libhello.so.1
ln -s libhello.so.1 libhello.so

動態庫和靜態庫的區別:
當要使用靜態的程序庫時,連接器會找出程序所需的函數,然後將它們拷貝到執行文件,由於這種拷貝是完整的,所以一旦連接成功,靜態程序庫也就不再需要了。然而,對動態庫而言,就不是這樣。動態庫會在執行程序內留下一個標記『指明當程序執行時,首先必須載入這個庫。由於動態庫節省空間,linux下進行連接的預設操作是首先連接動態庫,也就是說,如果同時存在靜態和動態庫,不特別指定的話,將與動態庫相連接。

兩種庫的編譯產生方法:
第一步要把源代碼編繹成目標代碼。以下面的代碼hello.c為例,生成hello庫:

/* hello.c */
#include
void sayhello()
{
printf("hello,world\n");
}
用gcc編繹該文件,在編繹時可以使用任何全法的編繹參數,例如-g加入調試代碼等:
gcc -c hello.c -o hello.o
1.連接成靜態庫
連接成靜態庫使用ar命令,其實ar是archive的意思
$ar cqs libhello.a hello.o
2.連接成動態庫
生成動態庫用gcc來完成,由於可能存在多個版本,因此通常指定版本號:
$gcc -shared -Wl,-soname,libhello.so.1 -o libhello.so.1.0 hello.o
另外再建立兩個符號連接:
$ln -s libhello.so.1.0 libhello.so.1
$ln -s libhello.so.1 libhello.so
這樣一個libhello的動態連接庫就生成了。最重要的是傳gcc -shared 參數使其生成是動態庫而不是普通執行程序。
-Wl 表示後面的參數也就是-soname,libhello.so.1直接傳給連接器ld進行處理。實際上,每一個庫都有一個soname,當連接器發現它正在查找的程序庫中有這樣一個名稱,連接器便會將soname嵌入連結中的二進制文件內,而不是它正在運行的實際文件名,在程序執行期間,程序會查找擁有 soname名字的文件,%B

Ⅳ 怎樣使用動態庫中的條件編譯

publicstaticvoidabc(){#region要執行的代碼stringstrCode=@"usingSystem;usingSystem.Text;usingSystem.Collections.Generic;usingSystem.Linq;namespaceaaa{publicclassbbb{publicstaticstringccc(stringname){return""abc"";}}}";#endregion#region編譯參數=newCompilerParameters();objCompilerParams.GenerateExecutable=false;//編譯成exe還是dllobjCompilerParams.GenerateInMemory=false;//是否寫入內存,不寫入內存就寫入磁碟objCompilerParams.OutputAssembly="E:\abc.dll";//輸出路徑objCompilerParams.IncludeDebugInformation=false;//是否產生pdb調試文件默認是falseobjCompilerParams.ReferencedAssemblies.Add("System.dll");objCompilerParams.ReferencedAssemblies.Add("System.Core.dll");//編譯器選項:編譯成(存儲在內存中)的DLL/*objCompilerParams.CompilerOptions="/target:library/optimize";//編譯時在內存輸出objCompilerParams.GenerateInMemory=true;//不生成調試信息objCompilerParams.IncludeDebugInformation=false;*/#endregion#region編譯//創建編譯類CSharpCodeProviderobjCompiler=newCSharpCodeProvider();//進行編譯=objCompiler.CompileAssemblyFromSource(objCompilerParams,strCode);#endregion#region取得編譯成程序集,准備執行程序集里的類中的方法//獲取編譯結果:程序集AssemblyobjAssembly=objCompileResults.CompiledAssembly;//獲取編譯成的程序集的信息/*objectobjMainClassInstance=objAssembly.CreateInstance("Program");TypeobjMainClassType=objMainClassInstance.GetType();*/#endregion#region調用程序集中的類,執行類中的方法,得到結果/*objMainClassType.GetMethod("Main").Invoke(objMainClassInstance,null);objMainClassType.GetMethod("PrintWorld").Invoke(objMainClassInstance,null);*/#endregion

Ⅵ 動態庫和靜態庫的區別

兩者區別:
a,靜態庫的使用需要:
1 包含一個對應的頭文件告知編譯器lib文件裡面的具體內容
2 設置lib文件允許編譯器去查找已經編譯好的二進制代碼

b,動態庫的使用:
程序運行時需要載入動態庫,對動態庫有依賴性,需要手動加入動態庫

c,依賴性:
靜態鏈接表示靜態性,在編譯鏈接之後, lib庫中需要的資源已經在可執行程序中了, 也就是靜態存在,沒有依賴性了
動態,就是實時性,在運行的時候載入需要的資源,那麼必須在運行的時候提供 需要的 動態庫,有依賴性, 運行時候沒有找到庫就不能運行了

d,區別:
簡單講,靜態庫就是直接將需要的代碼連接進可執行程序;動態庫就是在需要調用其中的函數時,根據函數映射表找到該函數然後調入堆棧執行。
做成靜態庫可執行文件本身比較大,但不必附帶動態庫
做成動態庫可執行文件本身比較小,但需要附帶動態庫
鏈接靜態庫,編譯的可執行文件比較大,當然可以用strip命令精簡一下(如:strip libtest.a),但還是要比鏈接動態庫的可執行文件大。程序運行時間速度稍微快一點。
靜態庫是程序運行的時候已經調入內存,不管有沒有調用,都會在內存里頭。靜態庫在程序編譯時會被連接到目標代碼中,程序運行時將不再需要該靜態庫。
其在編譯程序時若鏈接,程序運行時會在系統指定的路徑下搜索,然後導入內存,程序一般執行時間稍微長一點,但編譯的可執行文件比較小;動態庫是程序運行的時候需要調用的時候才裝入內存,不需要的時候是不會裝入內存的。
動態庫在程序編譯時並不會被連接到目標代碼中,而是在程序運行是才被載入,因此在程序運行時還需要動態庫存在。

動態鏈接庫的特點與優勢

首先讓我們來看一下,把庫函數推遲到程序運行時期載入的好處:

1. 可以實現進程之間的資源共享。

什麼概念呢?就是說,某個程序的在運行中要調用某個動態鏈接庫函數的時候,操作系統首先會查看所有正在運行的程序,看在內存里是否已有此庫函數的拷貝了。如果有,則讓其共享那一個拷貝;只有沒有才鏈接載入。這樣的模式雖然會帶來一些「動態鏈接」額外的開銷,卻大大的節省了系統的內存資源。C的標准庫就是動態鏈接庫,也就是說系統中所有運行的程序共享著同一個C標准庫的代碼段。

2. 將一些程序升級變得簡單。用戶只需要升級動態鏈接庫,而無需重新編譯鏈接其他原有的代碼就可以完成整個程序的升級。Windows 就是一個很好的例子。

3. 甚至可以真正坐到鏈接載入完全由程序員在程序代碼中控制。

程序員在編寫程序的時候,可以明確的指明什麼時候或者什麼情況下,鏈接載入哪個動態鏈接庫函數。你可以有一個相當大的軟體,但每次運行的時候,由於不同的操作需求,只有一小部分程序被載入內存。所有的函數本著「有需求才調入」的原則,於是大大節省了系統資源。比如現在的軟體通常都能打開若干種不同類型的文件,這些讀寫操作通常都用動態鏈接庫來實現。在一次運行當中,一般只有一種類型的文件將會被打開。所以直到程序知道文件的類型以後再載入相應的讀寫函數,而不是一開始就將所有的讀寫函數都載入,然後才發覺在整個程序中根本沒有用到它們。

靜態庫:在編譯的時候載入生成目標文件,在運行時不用載入庫,在運行時對庫沒有依賴性。
動態庫:在目標文件運行時載入,手動載入,且對庫有依賴性。

具體在開發中用到哪種庫,我覺得還是根據實際的內存大小,ROM大小,運行的速度等綜合考慮。

Ⅶ 如何在vc中使用mingw編譯出來的動態庫和靜態庫

mingw編譯出來的靜態庫後綴名為.a,編譯出來的動態庫的導入庫後綴名為.dll.a,而在windows下後綴名為.lib的庫可能是靜態庫也可能是動態庫的導入庫。

mingw編譯出來的動態庫的導入庫可以直接在vc中直接使用,例如

#pragma comment(lib, "libx264.dll.a")

這樣你就不需要生成一個.lib後綴的動態庫的導入庫了,網上也有如何從.dll生成.lib的方法。

如果鏈接了動態庫的導入庫libpthread.dll.a,你發布的應用程序就要帶上pthread的dll。
使用靜態庫的好處是發布的應用程序組件模塊里不需要帶上相關的dll,如果要使用mingw編譯出來的靜態庫,可以如下:

#pragma comment(lib, "libx264.a")

但是僅僅鏈接這么一個靜態庫是不夠的,你還需要鏈接

libgcc.a

libmingwex.a

你可能還需要鏈接libmsvcrt.a

否則會報一堆錯誤:error LNK2001: 無法解析的外部符號

上面的這些庫在C:\MinGW\lib目錄或子目錄下面可以找到。

鏈接這些庫的原因是mingw使用的gcc編譯器和vc編譯器之間存在差異

Ⅷ 關於c/c++靜態庫和動態庫的區別

靜態庫

之所以成為【靜態庫】,是因為在鏈接階段,會將匯編生成的目標文件.o與引用到的庫一起鏈接打包到可執行文件中。因此對應的鏈接方式稱為靜態鏈接。

試想一下,靜態庫與匯編生成的目標文件一起鏈接為可執行文件,那麼靜態庫必定跟.o文件格式相似。其實一個靜態庫可以簡單看成是一組目標文件(.o/.obj文件)的集合,即很多目標文件經過壓縮打包後形成的一個文件。靜態庫特點總結:

l 靜態庫對函數庫的鏈接是放在編譯時期完成的。

l 程序在運行時與函數庫再無瓜葛,移植方便。

l 浪費空間和資源,因為所有相關的目標文件與牽涉到的函數庫被鏈接合成一個可執行文件。

下面編寫一些簡單的四則運算C++類,將其編譯成靜態庫給他人用,頭文件如下所示:

StaticMath.h頭文件

#pragma once

class StaticMath

{

public:

StaticMath(void);

~StaticMath(void);

static double add(double a, double b);//加法

static double sub(double a, double b);//減法

static double mul(double a, double b);//乘法

static double div(double a, double b);//除法

void print();

};

Linux下使用ar工具、Windows下vs使用lib.exe,將目標文件壓縮到一起,並且對其進行編號和索引,以便於查找和檢索。一般創建靜態庫的步驟如圖所示:

圖:創建靜態庫過程

Linux下創建與使用靜態庫

Linux靜態庫命名規則

Linux靜態庫命名規范,必須是"lib[your_library_name].a":lib為前綴,中間是靜態庫名,擴展名為.a。

創建靜態庫(.a)

通過上面的流程可以知道,Linux創建靜態庫過程如下:

l 首先,將代碼文件編譯成目標文件.o(StaticMath.o)

g++ -c StaticMath.cpp

注意帶參數-c,否則直接編譯為可執行文件

l 然後,通過ar工具將目標文件打包成.a靜態庫文件

ar -crv libstaticmath.a StaticMath.o

生成靜態庫libstaticmath.a。

大一點的項目會編寫makefile文件(CMake等等工程管理工具)來生成靜態庫,輸入多個命令太麻煩了。

使用靜態庫

編寫使用上面創建的靜態庫的測試代碼:

測試代碼:

#include "StaticMath.h"

#include <iostream>

using namespace std;

int main(int argc, char* argv[])

{

double a = 10;

double b = 2;

cout << "a + b = " << StaticMath::add(a,
b) << endl;

cout << "a - b = " << StaticMath::sub(a,
b) << endl;

cout << "a * b = " << StaticMath::mul(a,
b) << endl;

cout << "a / b = " << StaticMath::div(a,
b) << endl;

StaticMath sm;

sm.print();

system("pause");

return 0;

}

Linux下使用靜態庫,只需要在編譯的時候,指定靜態庫的搜索路徑(-L選項)、指定靜態庫名(不需要lib前綴和.a後綴,-l選項)。

# g++ TestStaticLibrary.cpp -L../StaticLibrary -lstaticmath

l -L:表示要連接的庫所在目錄

l -l:指定鏈接時需要的動態庫,編譯器查找動態連接庫時有隱含的命名規則,即在給出的名字前面加上lib,後面加上.a或.so來確定庫的名稱。

Windows下創建與使用靜態庫

創建靜態庫(.lib)

如果是使用VS命令行生成靜態庫,也是分兩個步驟來生成程序:

l 首先,通過使用帶編譯器選項 /c 的 Cl.exe 編譯代碼 (cl
/c StaticMath.cpp),創建名為「StaticMath.obj」的目標文件。

l 然後,使用庫管理器 Lib.exe 鏈接代碼 (lib StaticMath.obj),創建靜態庫StaticMath.lib。

當然,我們一般不這么用,使用VS工程設置更方便。創建win32控制台程序時,勾選靜態庫類型;打開工程「屬性面板」è」配置屬性」è」常規」,配置類型選擇靜態庫。

圖:vs靜態庫項目屬性設置

Build項目即可生成靜態庫。

使用靜態庫

測試代碼Linux下面的一樣。有3種使用方法:

方法一:

在VS中使用靜態庫方法:

l 工程「屬性面板」è「通用屬性」è 「框架和引用」è」添加引用」,將顯示「添加引用」對話框。 「項目」選項卡列出了當前解決方案中的各個項目以及可以引用的所有庫。 在「項目」選項卡中,選擇 StaticLibrary。 單擊「確定」。

l 添加StaticMath.h 頭文件目錄,必須修改包含目錄路徑。打開工程「屬性面板」è」配置屬性」è 「C/C++」è」 常規」,在「附加包含目錄」屬性值中,鍵入StaticMath.h 頭文件所在目錄的路徑或瀏覽至該目錄。

編譯運行OK。

圖:靜態庫測試結果(vs)

如果引用的靜態庫不是在同一解決方案下的子工程,而是使用第三方提供的靜態庫lib和頭文件,上面的方法設置不了。還有2中方法設置都可行。

方法二:

打開工程「屬性面板」è」配置屬性」è 「鏈接器」è」命令行」,輸入靜態庫的完整路徑即可。

方法三:

l 「屬性面板」è」配置屬性」è 「鏈接器」è」常規」,附加依賴庫目錄中輸入,靜態庫所在目錄;

l 「屬性面板」è」配置屬性」è 「鏈接器」è」輸入」,附加依賴庫中輸入靜態庫名StaticLibrary.lib。

動態庫

通過上面的介紹發現靜態庫,容易使用和理解,也達到了代碼復用的目的,那為什麼還需要動態庫呢?

為什麼還需要動態庫?

為什麼需要動態庫,其實也是靜態庫的特點導致。

l 空間浪費是靜態庫的一個問題。

l 另一個問題是靜態庫對程序的更新、部署和發布頁會帶來麻煩。如果靜態庫liba.lib更新了,所以使用它的應用程序都需要重新編譯、發布給用戶(對於玩家來說,可能是一個很小的改動,卻導致整個程序重新下載,全量更新)。

動態庫在程序編譯時並不會被連接到目標代碼中,而是在程序運行是才被載入。不同的應用程序如果調用相同的庫,那麼在內存里只需要有一份該共享庫的實例,規避了空間浪費問題。動態庫在程序運行是才被載入,也解決了靜態庫對程序的更新、部署和發布頁會帶來麻煩。用戶只需要更新動態庫即可,增量更新。

動態庫特點總結:

l 動態庫把對一些庫函數的鏈接載入推遲到程序運行的時期。

l 可以實現進程之間的資源共享。(因此動態庫也稱為共享庫)

l 將一些程序升級變得簡單。

l 甚至可以真正做到鏈接載入完全由程序員在程序代碼中控制(顯示調用)。

Window與Linux執行文件格式不同,在創建動態庫的時候有一些差異。

l 在Windows系統下的執行文件格式是PE格式,動態庫需要一個DllMain函數做出初始化的入口,通常在導出函數的聲明時需要有_declspec(dllexport)關鍵字。

l Linux下gcc編譯的執行文件默認是ELF格式,不需要初始化入口,亦不需要函數做特別的聲明,編寫比較方便。

與創建靜態庫不同的是,不需要打包工具(ar、lib.exe),直接使用編譯器即可創建動態庫。

Linux下創建與使用動態庫

linux動態庫的命名規則

動態鏈接庫的名字形式為 libxxx.so,前綴是lib,後綴名為「.so」。

l 針對於實際庫文件,每個共享庫都有個特殊的名字「soname」。在程序啟動後,程序通過這個名字來告訴動態載入器該載入哪個共享庫。

l 在文件系統中,soname僅是一個鏈接到實際動態庫的鏈接。對於動態庫而言,每個庫實際上都有另一個名字給編譯器來用。它是一個指向實際庫鏡像文件的鏈接文件(lib+soname+.so)。

創建動態庫(.so)

編寫四則運算動態庫代碼:

DynamicMath.h頭文件

#pragma once

class DynamicMath

{

public:

DynamicMath(void);

~DynamicMath(void);

static double add(double a, double b);//¼Ó·¨

static double sub(double a, double b);//¼õ·¨

static double mul(double a, double b);//³Ë·¨

static double div(double a, double b);//³ý·¨

void print();

};

l 首先,生成目標文件,此時要加編譯器選項-fpic

g++ -fPIC -c DynamicMath.cpp

-fPIC 創建與地址無關的編譯程序(pic,position independent code),是為了能夠在多個應用程序間共享。

l 然後,生成動態庫,此時要加鏈接器選項-shared

g++ -shared -o libdynmath.so DynamicMath.o

-shared指定生成動態鏈接庫。

其實上面兩個步驟可以合並為一個命令:

g++ -fPIC -shared -o libdynmath.so DynamicMath.cpp

使用動態庫

編寫使用動態庫的測試代碼:

測試代碼:

#include "../DynamicLibrary/DynamicMath.h"

#include <iostream>

using namespace std;

int main(int argc, char* argv[])

{

double a = 10;

double b = 2;

cout << "a + b = " << DynamicMath::add(a, b) << endl;

cout << "a - b = " << DynamicMath::sub(a, b) << endl;

cout << "a * b = " << DynamicMath::mul(a, b) << endl;

cout << "a / b = " << DynamicMath::div(a, b) << endl;

DynamicMath dyn;

dyn.print();

return 0;

}

引用動態庫編譯成可執行文件(跟靜態庫方式一樣):

g++ TestDynamicLibrary.cpp -L../DynamicLibrary -ldynmath

然後運行:./a.out,發現竟然報錯了!!!

可能大家會猜測,是因為動態庫跟測試程序不是一個目錄,那我們驗證下是否如此:

發現還是報錯!!!那麼,在執行的時候是如何定位共享庫文件的呢?

1) 當系統載入可執行代碼時候,能夠知道其所依賴的庫的名字,但是還需要知道絕對路徑。此時就需要系統動態載入器(dynamic linker/loader)。

2) 對於elf格式的可執行程序,是由ld-linux.so*來完成的,它先後搜索elf文件的DT_RPATH段—環境變數LD_LIBRARY_PATH—/etc/ld.so.cache文件列表—/lib/,/usr/lib 目錄找到庫文件後將其載入內存。

如何讓系統能夠找到它:

l 如果安裝在/lib或者/usr/lib下,那麼ld默認能夠找到,無需其他操作。

l 如果安裝在其他目錄,需要將其添加到/etc/ld.so.cache文件中,步驟如下:

n 編輯/etc/ld.so.conf文件,加入庫文件所在目錄的路徑

n 運行ldconfig ,該命令會重建/etc/ld.so.cache文件

我們將創建的動態庫復制到/usr/lib下面,然後運行測試程序。

Windows下創建與使用動態庫

創建動態庫(.dll)

與Linux相比,在Windows系統下創建動態庫要稍微麻煩一些。首先,需要一個DllMain函數做出初始化的入口(創建win32控制台程序時,勾選DLL類型會自動生成這個文件):

dllmain.cpp入口文件

// dllmain.cpp : Defines the entry point for the DLL application.

#include "stdafx.h"

BOOL APIENTRY DllMain( HMODULE 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:

break;

}

return TRUE;

}

通常在導出函數的聲明時需要有_declspec(dllexport)關鍵字:

DynamicMath.h頭文件

#pragma once

class DynamicMath

{

public:

__declspec(dllexport) DynamicMath(void);

__declspec(dllexport) ~DynamicMath(void);

static __declspec(dllexport) double add(double a, double b);//加法

static __declspec(dllexport) double sub(double a, double b);//減法

static __declspec(dllexport) double mul(double a, double b);//乘法

static __declspec(dllexport) double div(double a, double b);//除法

__declspec(dllexport) void print();

};

生成動態庫需要設置工程屬性,打開工程「屬性面板」è」配置屬性」è」常規」,配置類型選擇動態庫。

圖:v動態庫項目屬性設置

Build項目即可生成動態庫。

使用動態庫

創建win32控制台測試程序:

TestDynamicLibrary.cpp測試程序

#include "stdafx.h"

#include "DynamicMath.h"

#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])

{

double a = 10;

double b = 2;

cout << "a + b = " << DynamicMath::add(a,
b) << endl;

cout << "a - b = " << DynamicMath::sub(a,
b) << endl;

cout << "a * b = " << DynamicMath::mul(a,
b) << endl;

cout << "a / b = " << DynamicMath::div(a,
b) << endl;

DynamicMath dyn;

dyn.print();

system("pause");

return 0;

}

方法一:

l 工程「屬性面板」è「通用屬性」è 「框架和引用」è」添加引用」,將顯示「添加引用」對話框。「項目」選項卡列出了當前解決方案中的各個項目以及可以引用的所有庫。 在「項目」選項卡中,選擇 DynamicLibrary。 單擊「確定」。

l 添加DynamicMath.h 頭文件目錄,必須修改包含目錄路徑。打開工程「屬性面板」è」配置屬性」è 「C/C++」è」 常規」,在「附加包含目錄」屬性值中,鍵入DynamicMath.h 頭文件所在目錄的路徑或瀏覽至該目錄。

編譯運行OK。

圖:動態庫測試結果(vs)

方法二:

l 「屬性面板」è」配置屬性」è 「鏈接器」è」常規」,附加依賴庫目錄中輸入,動態庫所在目錄;

l 「屬性面板」è」配置屬性」è 「鏈接器」è」輸入」,附加依賴庫中輸入動態庫編譯出來的DynamicLibrary.lib。

這里可能大家有個疑問,動態庫怎麼還有一個DynamicLibrary.lib文件?即無論是靜態鏈接庫還是動態鏈接庫,最後都有lib文件,那麼兩者區別是什麼呢?其實,兩個是完全不一樣的東西。

StaticLibrary.lib的大小為190KB,DynamicLibrary.lib的大小為3KB,靜態庫對應的lib文件叫靜態庫,動態庫對應的lib文件叫【導入庫】。實際上靜態庫本身就包含了實際執行代碼、符號表等等,而對於導入庫而言,其實際的執行代碼位於動態庫中,導入庫只包含了地址符號表等,確保程序找到對應函數的一些基本地址信息。

動態庫的顯式調用

上面介紹的動態庫使用方法和靜態庫類似屬於隱式調用,編譯的時候指定相應的庫和查找路徑。其實,動態庫還可以顯式調用。【在C語言中】,顯示調用一個動態庫輕而易舉!

在Linux下顯式調用動態庫

#include <dlfcn.h>,提供了下面幾個介面:

l void * dlopen( const char * pathname, int mode ):函數以指定模式打開指定的動態連接庫文件,並返回一個句柄給調用進程。

l void* dlsym(void* handle,const char* symbol):dlsym根據動態鏈接庫操作句柄(pHandle)與符號(symbol),返回符號對應的地址。使用這個函數不但可以獲取函數地址,也可以獲取變數地址。

l int dlclose (void *handle):dlclose用於關閉指定句柄的動態鏈接庫,只有當此動態鏈接庫的使用計數為0時,才會真正被系統卸載。

l const char *dlerror(void):當動態鏈接庫操作函數執行失敗時,dlerror可以返回出錯信息,返回值為NULL時表示操作函數執行成功。

在Windows下顯式調用動態庫

應用程序必須進行函數調用以在運行時顯式載入 DLL。為顯式鏈接到 DLL,應用程序必須:

l 調用 LoadLibrary(或相似的函數)以載入 DLL 和獲取模塊句柄。

l 調用 GetProcAddress,以獲取指向應用程序要調用的每個導出函數的函數指針。由於應用程序是通過指針調用 DLL 的函數,編譯器不生成外部引用,故無需與導入庫鏈接。

l 使用完 DLL 後調用 FreeLibrary。

顯式調用C++動態庫注意點

對C++來說,情況稍微復雜。顯式載入一個C++動態庫的困難一部分是因為C++的name
mangling;另一部分是因為沒有提供一個合適的API來裝載類,在C++中,您可能要用到庫中的一個類,而這需要創建該類的一個實例,這不容易做到。

name mangling可以通過extern "C"解決。C++有個特定的關鍵字用來聲明採用C
binding的函數:extern "C" 。用 extern "C"聲明的函數將使用函數名作符號名,就像C函數一樣。因此,只有非成員函數才能被聲明為extern
"C",並且不能被重載。盡管限制多多,extern "C"函數還是非常有用,因為它們可以象C函數一樣被dlopen動態載入。冠以extern
"C"限定符後,並不意味著函數中無法使用C++代碼了,相反,它仍然是一個完全的C++函數,可以使用任何C++特性和各種類型的參數。

Ⅸ 如何用gcc編譯動態庫

今天要用到靜態庫和動態庫,於是寫了幾個例子來鞏固一下基礎。
hello1.c ————————————————————
#include <stdio.h>
void print1(int i) { int j; for(j=0;j<i;j++) { printf("%d * %d = %d\n",j,j,j*j); } }
hello2.c _________________________________________________
#include <stdio.h>
void print2(char *arr) { char c; int i=0; while((c=arr[i++])!='\0') { printf("%d****%c\n",i,c); } }
hello.c ____________________________________________________
void print1(int); void print2(char *);
int main(int argc,char **argv) { int i=100; char *arr="THIS IS LAYMU'S HOME!"; print1(i); print2(arr);
return 0; }

可以看到hello.c要用到hello1.c中的print1函數和hello2.c中的print2函數。所以可以把這兩個函數組合為庫,以供更多的程序作為組件來調用。

方法一:將hello1.c和hello2.c編譯成靜態鏈接庫.a
[root@localhost main5]#gcc -c hello1.c hello2.c
//將hello1.c和hello2.c分別編譯為hello1.o和hello2.o,其中-c選項意為只編譯不鏈接。
[root@localhost main5]#ar -r libhello.a hello1.o hello2.o
//將hello1.o和hello2.o組合為libhello.a這個靜態鏈接庫
[root@localhost main5]#cp libhello.a /usr/lib
//將libhello.a拷貝到/usr/lib目錄下,作為一個系統共享的靜態鏈接庫
[root@localhost main5]#gcc -o hello hello.c -lhello
//將hello.c編譯為可執行程序hello,這個過程用到了-lhello選項,這個選項告訴gcc編譯器到/usr/lib目錄下去找libhello.a的靜態鏈接庫
以上的過程類似於windows下的lib靜態鏈接庫的編譯及調用過程。
方法二:將hello1.o和hello2.o組合成動態鏈接庫.so
[root@localhost main5]#gcc -c -fpic hello1.c hello2.c
//將hello1.c和hello2.c編譯成hello1.o和hello2.o,-c意為只編譯不鏈接,-fpic意為位置獨立代碼,指示編譯程序生成的代碼要適合共享庫的內容這樣的代碼能夠根據載入內存的位置計算內部地址。
[root@localhost main5]#gcc -shared hello1.o hello2.o -o hello.so
//將hello1.o和hello2.o組合為shared object,即動態鏈接庫
[root@localhost main5]#cp hello.so /usr/lib
//將hello.so拷貝到/usr/lib目錄下
[root@localhost main5]#gcc -o hello hello.c hello.so
//將hello.c編譯鏈接為hello的可執行程序,這個過程用到了動態鏈接庫hello.so

在這里要廢話幾句,其實一切的二進制信息都有其運作的機制,只要弄清楚了它的機制,並能夠實現之,則任何此時此刻無法想像之事都將成為現實。當然,這兩者之間的巨大鴻溝需要頂級的設計思想和頂級的代碼來跨越。

熱點內容
java軟體免費下載 發布:2025-03-20 10:26:01 瀏覽:704
安卓用什麼編譯 發布:2025-03-20 10:25:57 瀏覽:808
ftp中文軟體下載 發布:2025-03-20 10:07:47 瀏覽:508
nexus7android 發布:2025-03-20 10:06:58 瀏覽:619
安舍iq8如何修改密碼 發布:2025-03-20 10:06:17 瀏覽:880
解壓RTP 發布:2025-03-20 09:59:37 瀏覽:161
python量化分析 發布:2025-03-20 09:53:05 瀏覽:626
手機熱點有限的訪問許可權 發布:2025-03-20 09:50:46 瀏覽:440
為什麼安卓沒有ios系統流暢 發布:2025-03-20 09:50:43 瀏覽:793
python編程實例 發布:2025-03-20 09:48:19 瀏覽:294