這裡蒐索程式師資訊,查找有用的技術資料
當前位置:首頁 » 編程語言 » c語言dlsym
擴展閱讀
webinf下怎麼引入js 2023-08-31 21:54:13
堡壘機怎麼打開web 2023-08-31 21:54:11

c語言dlsym

發布時間: 2022-04-17 05:46:20

⑴ 如何在android studio中用JNI調用靜態庫

android ndk開發經常遇到了動態庫的問題,本文主要介紹: ① 動態鏈接庫的生成; ② 在Java和C混合編程的情況下如何調用第三方動態鏈接庫; ③ 使用dlopen程序運行時直接調用; ④ 純c的方式開發調用; 本文重點推薦②和④,第③中太麻煩每個函數都需要dlsym調用一次; 代碼的網路雲鏈接: pan/s/1dD3qkQ9 密碼:c5s3 工具/原料 Win8/article/63f236280b90690208ab3d12/article/c910274bfdd000cd371d2d4b/p/3247530080 2 根據「生成動態庫」中的過程1到10,新建一個純c的ndk程序: 「D:\Android\android-ndk-r10\samples\native-activity" 3 把會用的so文件的目錄libs拷貝到 jni目錄下面 4 修改 Android.mk 文件,內容如下: LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := fkAdd LOCAL_SRC_FILES := libs/$(TARGET_ARCH_ABI)/libfkAdd.so include $(PREBUILT_SHARED_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE := main LOCAL_SRC_FILES := main.c LOCAL_LDLIBS := -llog -landroid -lEGL -lGLESv1_CM LOCAL_STATIC_LIBRARIES := android_native_app_glue LOCAL_SHARED_LIBRARIES := fkAdd include $(BUILD_SHARED_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE := native-activity LOCAL_SRC_FILES := NativeActivity.c LOCAL_LDLIBS := -llog -landroid LOCAL_STATIC_LIBRARIES := android_native_app_glue include $(BUILD_SHARED_LIBRARY) $(call import-mole,android/native_app_glue) 5 增加 NativeActivity.c 文件,添加內容如下: #include <jni.h> #include <errno.h> #include <dlfcn.h> #include <android_native_app_glue.h> void android_main(struct android_app* state) { // Make sure glue isn't stripped. app_mmy(); void* soAdd = dlopen("/data/data/com.example.native_activity/ lib/libfkAdd.so",RTLD_NOW); void* soMain = dlopen("/data/data/com.example.native_activity/ lib/libmain.so",RTLD_NOW); void (*fp_android_main)(struct android_app*) = (void (*)(struct android_app*))dlsym(soMain,"android_main"); fp_android_main(state); dlclose(soMain); dlclose(soAdd); } 6 在 main.c 文件中添加一行,方便測試: __android_log_print(ANDROID_LOG_DEBUG, "fuke", "engine_handle_input 100 + 200 = [%d] ", fkAdd(100, 200)); 7 編譯運行,點擊手機屏幕後,觀察logcat 效果如下: END 注意事項 c++的函數在寫動態鏈接庫的時候,需要注意的是c++的函數會被系統修改,所以做動態庫測試的使用最好用c語言

⑵ C庫如何封裝成C++介面

C一般不能直接調用C++函數庫,需要將C++庫封裝成C介面後,才可以使用C調用。
下面舉例,說明一個封裝策略:

//code in add.cxx
#include "add.h"
int sample::method()
{
cout<<"method is called!\n";
}
//code in add.h
#include
using namespace std;
class sample
{
public:
int method();
};
將上面的兩個文件生成動態庫libadd.so放到 /usr/lib目錄下,編譯命令如下:
sudo g++ -fpic -shared -g -o /usr/lib/libadd.so add.cxx -I ./
由於在C中不能識別類,所以要將上面類的成員函數,要封裝成C介面函數才能被調用。下面進行封裝,將輸出介面轉換成C介面。
//code in mylib.cxx
#include "add.h"
#ifndef _cplusplus
#define _cplusplus
#include "mylib.h"
#endif

int myfunc()
{
sample ss;
ss.method();
return 0;
}
//code in mylib.h
#ifdef _cplusplus
extern "C"
{
#endif

int myfunc();

#ifdef _cplusplus
}
#endif
在linux下,gcc編譯器並沒用變數_cplusplus來區分是C代碼還是C++ 代碼(沒有宏定義),如果使用gcc編譯器,這里我們可以自己定義一個變數_cplusplus用於區分C和C++代碼,所以在mylib.cxx中定義 了一個變數_cplusplus用於識別是否需要「extern "C"」將函數介面封裝成C介面。但是如果使用g++編譯器則不需要專門定義_cplusplus,編譯命令如下:
g++ -fpic -shared -g -o mylib.so mylib.cxx -la -I ./
main.c
#include

#include
#include "mylib.h"

int
main()
{
int (*dlfunc)();
void *handle; //定義一個句柄
handle = dlopen("./mylib.so", RTLD_LAZY);//獲得庫句柄
dlfunc = dlsym(handle, "myfunc"); //獲得函數入口
(*dlfunc)();
dlclose(handle);

return 0;
}
編譯命令如下:
gcc -o main main.c ./mylib.so -ldl
下面就可以執行了。
需要說明的是,由於main.c 和 mylib.cxx都需要包含mylib.h,並且要將函數myfunc封裝成C介面函數輸出需要「extern "C"」,而C又不識別「extern "C"」,所以需要定義_cplusplus來區別處理mylib.h中的函數myfunc。
在main.c的main函數中直接調用myfunc()函數也能執行,這里介紹的是常規調用庫函數的方法。

⑶ linux C語言,用代碼有方法判斷一個庫裡面是否有一個介面嗎

用dlopen()打開a.so
然後用dlsym()來獲取test介面的指針,如果取到了就有,反之沒有

⑷ 如何用C語言封裝 C++的類,在 C裡面使用

C一般不能直接調用C++函數庫,需要將C++庫封裝成C介面後,才可以使用C調用。
下面舉例,說明一個封裝策略:

//code in add.cxx
#include "add.h"
int sample::method()
{
cout<<"method is called!\n";
}
//code in add.h
#include
using namespace std;
class sample
{
public:
int method();
};
將上面的兩個文件生成動態庫libadd.so放到 /usr/lib目錄下,編譯命令如下:
sudo g++ -fpic -shared -g -o /usr/lib/libadd.so add.cxx -I ./
由於在C中不能識別類,所以要將上面類的成員函數,要封裝成C介面函數才能被調用。下面進行封裝,將輸出介面轉換成C介面。
//code in mylib.cxx
#include "add.h"
#ifndef _cplusplus
#define _cplusplus
#include "mylib.h"
#endif

int myfunc()
{
sample ss;
ss.method();
return 0;
}
//code in mylib.h
#ifdef _cplusplus
extern "C"
{
#endif

int myfunc();

#ifdef _cplusplus
}
#endif
在linux下,gcc編譯器並沒用變數_cplusplus來區分是C代碼還是C++ 代碼(沒有宏定義),如果使用gcc編譯器,這里我們可以自己定義一個變數_cplusplus用於區分C和C++代碼,所以在mylib.cxx中定義 了一個變數_cplusplus用於識別是否需要「extern "C"」將函數介面封裝成C介面。但是如果使用g++編譯器則不需要專門定義_cplusplus,編譯命令如下:
g++ -fpic -shared -g -o mylib.so mylib.cxx -la -I ./
main.c
#include

#include
#include "mylib.h"

int
main()
{
int (*dlfunc)();
void *handle; //定義一個句柄
handle = dlopen("./mylib.so", RTLD_LAZY);//獲得庫句柄
dlfunc = dlsym(handle, "myfunc"); //獲得函數入口
(*dlfunc)();
dlclose(handle);

return 0;
}
編譯命令如下:
gcc -o main main.c ./mylib.so -ldl
下面就可以執行了。
需要說明的是,由於main.c 和 mylib.cxx都需要包含mylib.h,並且要將函數myfunc封裝成C介面函數輸出需要「extern "C"」,而C又不識別「extern "C"」,所以需要定義_cplusplus來區別處理mylib.h中的函數myfunc。
在main.c的main函數中直接調用myfunc()函數也能執行,這里介紹的是常規調用庫函數的方法。

⑸ 關於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++特性和各種類型的參數。

⑹ 如何在Android Studio中導入JNI生成的.so庫

android ndk開發經常遇到了動態庫的問題,本文主要介紹:
① 動態鏈接庫的生成;
② 在Java和C混合編程的情況下如何調用第三方動態鏈接庫;
③ 使用dlopen程序運行時直接調用;
④ 純c的方式開發調用;
本文重點推薦②和④,第③中太麻煩每個函數都需要dlsym調用一次;

工具/原料
Win8.1 x64
adt-bundle-windows-x86_64-20140702
android-ndk-r10d
生成動態庫
1
android ndk下面生成動態庫so文件的方法很多,但是這里只提供一種方法,更多的生成方法可以看,「ndk 編譯靜態庫」:

2
fkAdd.c 的內容如下:
#include <jni.h>
int fkAdd(int nX, int nY)
{
return nX + nY;
}
3
Android.mk 的內容如下:
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE:= fkAdd
LOCAL_SRC_FILES:= fkAdd.c
include $(BUILD_SHRRED_LIBRARY)
4
1、打開 eclipse
2、點擊 文件
3、點擊 新建
4、點擊 other...

5
1、展開 Android 選項;
2、選擇 Android Project from Existing Code;
3、點擊 Next

6
1、輸入 Root Director;
2、取消 tests;
3、選中 Copy projects into workspace;
4、點擊 Finish;

7
1、右鍵工程;
2、選擇 Android Tools;
3、Add Native Support...;

8
點擊 Finish

9
修改android sdk 版本為 4.0.3;
關於如何修改 android sdk 版本:

10
修改 Min SDK version:15
修改 Target SDK version:19

步驟閱讀
11
在jni目錄下面新建文件fkAdd.c 的內容如下:
int fkAdd(int nX, int nY)
{
return nX + nY;
}

12
臨時修改 Android.mk 文件內容如下:
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
#LOCAL_MODULE := hello-jni
#LOCAL_SRC_FILES := hello-jni.c
LOCAL_MODULE := fkaddso
LOCAL_SRC_FILES := fkAdd.c
include $(BUILD_SHARED_LIBRARY)

13
使用快捷鍵Ctrl+B編譯後可以在libs目錄下面看到生成的一些列的
libfkaddso.so文件,如下圖所示

END
Java和c編程調so
1
1、將libs復制一份到jni目錄下面,刪掉其中不相關的文件
2、刪掉文件 jni/fkadd.c 文件
3、將 Android.mk 文件還原成最開始的樣子;

2
修改 hello-jni.c 中的部分代碼,如下:
char szMsg[1024] = {0};
int nSum = fkAdd(100, 10);
sprintf (szMsg, "Hello from JNI ! Compiled with ABI " ABI ". %d ", nSum);
return (*env)->NewStringUTF(env, szMsg);

3
修改 Android.mk 文件:
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)
LOCAL_MODULE := fkaddso
LOCAL_SRC_FILES := libs/$(TARGET_ARCH_ABI)/libfkaddso.so
include $(PREBUILT_SHARED_LIBRARY)

include $(CLEAR_VARS)

LOCAL_MODULE := hello-jni
LOCAL_SRC_FILES := hello-jni.c
LOCAL_SHARED_LIBRARIES := fkaddso

include $(BUILD_SHARED_LIBRARY)

4
修改 HelloJni.java 在其中增加一行:
System.loadLibrary("fkaddso");

5
運行工程看效果:

END
用dlopen調用so
1
重復「生成動態庫」中的過程1到10,
2
把需要調用so文件的目錄libs拷貝到jni目錄下面,並修改 Android.mk 文件的內容如下:
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)
LOCAL_MODULE := fkaddso
LOCAL_SRC_FILES := libs/$(TARGET_ARCH_ABI)/libfkaddso.so
include $(PREBUILT_SHARED_LIBRARY)

include $(CLEAR_VARS)
LOCAL_MODULE := hello-jni
LOCAL_SRC_FILES := hello-jni.c
include $(BUILD_SHARED_LIBRARY)

3
修改 hello-jni.c 的內容如下:
char* szSo = "/data/data/com.example.hellojni/lib/libfkaddso.so";
void* fkAddSo = dlopen(szSo, RTLD_LAZY);
int (*fpAdd)(int,int) = (int (*)(int,int))dlsym(fkAddSo, "fkAdd");
char szMsg[1024] = {0};
int nSum = fpAdd(100, 200);
dlclose(fkAddSo);
sprintf (szMsg, "%s %d", szSo, nSum);
return (*env)->NewStringUTF(env, szMsg);

4
關於如何獲取 so在手機中的路徑,可以通過在控制台下輸入 adb shell 後,
在手機上查詢:

5
編譯後運行效果:

6
方便他人亦是方便自己,如果覺得還行就點下下邊的投票吧,這樣可以幫助其他人更快的找到解決問題的方法;有疑問的也可留言哦, 謝謝!

END
純c的方式開發調用
1

2
根據「生成動態庫」中的過程1到10,新建一個純c的ndk程序:
「D:\Android\android-ndk-r10\samples\native-activity"

3
把會用的so文件的目錄libs拷貝到 jni目錄下面

4
修改 Android.mk 文件,內容如下:
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)
LOCAL_MODULE := fkAdd
LOCAL_SRC_FILES := libs/$(TARGET_ARCH_ABI)/libfkAdd.so
include $(PREBUILT_SHARED_LIBRARY)

include $(CLEAR_VARS)
LOCAL_MODULE := main
LOCAL_SRC_FILES := main.c
LOCAL_LDLIBS := -llog -landroid -lEGL -lGLESv1_CM
LOCAL_STATIC_LIBRARIES := android_native_app_glue
LOCAL_SHARED_LIBRARIES := fkAdd
include $(BUILD_SHARED_LIBRARY)

include $(CLEAR_VARS)
LOCAL_MODULE := native-activity
LOCAL_SRC_FILES := NativeActivity.c
LOCAL_LDLIBS := -llog -landroid
LOCAL_STATIC_LIBRARIES := android_native_app_glue
include $(BUILD_SHARED_LIBRARY)

$(call import-mole,android/native_app_glue)

5
增加 NativeActivity.c 文件,添加內容如下:
#include <jni.h>
#include <errno.h>
#include <dlfcn.h>

#include <android_native_app_glue.h>

void android_main(struct android_app* state) {

// Make sure glue isn't stripped.
app_mmy();

void* soAdd = dlopen("/data/data/com.example.native_activity/
lib/libfkAdd.so",RTLD_NOW);
void* soMain = dlopen("/data/data/com.example.native_activity/
lib/libmain.so",RTLD_NOW);

void (*fp_android_main)(struct android_app*) =
(void (*)(struct android_app*))dlsym(soMain,"android_main");

fp_android_main(state);

dlclose(soMain);
dlclose(soAdd);
}

6
在 main.c 文件中添加一行,方便測試:
__android_log_print(ANDROID_LOG_DEBUG, "fuke", "engine_handle_input 100 + 200 = [%d] ", fkAdd(100, 200));

7
編譯運行,點擊手機屏幕後,觀察logcat 效果如下:

END
注意事項
c++的函數在寫動態鏈接庫的時候,需要注意的是c++的函數會被系統修改,所以做動態庫測試的使用最好用c語言

⑺ 如何動態載入c++函數和類

當我們動態load .so庫後,用dlsym通過函數名來得到改函數的地址。在C語言中,你原代碼中的函數名稱和共享庫(.so)的文件名是一致的,能用dlsym來正確獲得。但c++由於要支持重載的原因,編譯器會根據自己的演算法來修改源代碼中的函數名。比如 foo(int,char),最後共享庫中的函數名很可能是 foo_int_char而不再是foo了。關鍵是c++標准並未制定如何對c++的函數名進行轉換,每個編譯器都有自己的一套做法。所以不可能在dlsym中進行c++函數名的轉換。既然dlsym無法處理名字轉換,我們唯一的方法是在寫庫時,讓庫生成c風格的函數名,再通過dlsym來獲得。 =========c++源代碼============ int foo(int) int foo(char); extern "c"{ int foo_int();//封裝foo(int) int foo_char();//封裝foo(char)}最後可以通過 dlsym("foo_int")和dlsym("foo_char") 對於c++類也是通過該方法來動態載入,其本質是自己制定一套命名轉換規則:) extern "c" int a;和 extern "c"{int a;}是不一樣的,前者既包括兩層含義,一是這個變數名是c風格,第二這個是extern變數,而後者僅僅是說明該變數是一個c風格。

⑻ 怎樣調用c++庫函數

C語言程序調用C++ 庫函數方法,關鍵是函數名字解析問題。 其實實現起來不是很難。

使用關鍵字 extern \"C\" 可以使得C++ 編譯器生成的函數名滿足C語言的要求

例子如下:

鏈接庫頭文件:
//head.h
class A
{
public:
A();
virtual ~A();
int gt();
int pt();
private:
int s;
};

.cpp
//firstso.cpp
#include
#include \"head.h\"

A::A(){}
A::~A(){}
int A::gt()
{
s=10;
}
int A::pt()
{

std::cout< }
編譯命令如下:
g++ -shared -o libmy.so firstso.cpp
這時候生成libmy.so文件,將其拷貝到系統庫裡面:/usr/lib/
進行二次封裝:
.cpp
//secso.cpp
#include
#include \"head.h\"
extern \"C\"

{

int f();

int f()
{
A a;
a.gt();
a.pt();
return 0;
}

}
編譯命令:
gcc -shared -o sec.so secso.cpp -L. -lmy [Page]
這時候生成第二個.so文件,此時庫從一個類變成了一個c的介面.
拷貝到/usr/lib
下面開始調用:
//test.c
#include \"stdio.h\"
#include \"dlfcn.h\"

#define SOFILE \"sec.so\"
int (*f)();
int main()
{
void *dp;
dp=dlopen(SOFILE,RTLD_LAZY);
f=dlsym(dp,\"f\");
f();
return 0;
}
編譯命令如下:
gcc -rdynamic -s -o myapp test.c
運行Z$./myapp
10
$

⑼ 如何在C++中使用共享庫的動態載入

一、先看看測試程序
1.庫部分
hello.h
[cpp] view plain
在CODE上查看代碼片派生到我的代碼片
#ifndef ANDROID_Hello_H
#define ANDROID_Hello_H
class Hello_Base
{
public:
virtual ~Hello_Base() {};
virtual int setctl(int ctl) = 0;
virtual int getctl(int ctl) = 0;
};
class Hello : public virtual Hello_Base
{
public:
virtual ~Hello() {};
static Hello* Instance();
int setctl(int ctl);
int getctl(int ctl);
private:
static Hello* _instance;
int myctl;
};
extern "C" Hello_Base* CreatHello();
typedef Hello_Base* CreatHelloClass();
#endif
hello.cpp
[cpp] view plain
在CODE上查看代碼片派生到我的代碼片
#include "hello.h"
#include <stdio.h>
extern "C" Hello_Base* CreatHello(){
return Hello::Instance();
}
Hello* Hello::_instance = 0;
Hello* Hello::Instance()
{
printf("TK------>>>>>>Hello::Instance---------\n");
if(_instance == 0){
_instance = new Hello();
}
return _instance;
}
int Hello::setctl(int ctl)
{
printf("TK------->>>>>>setctl-----\n");
this->myctl = ctl;
return 1;
}
int Hello::getctl(int ctl)
{
printf("TK------->>>>>>getctl-----\n");
return this->myctl;
}
編譯成動態鏈接庫,一般要求PIC位置無關:
g++ -shared -fPIC -o libhello.so hello.cpp
生成:libhello.so
2.測試用例
test.cpp
[cpp] view plain
在CODE上查看代碼片派生到我的代碼片
#include "so/hello.h"
#include <stdio.h>
#include <dlfcn.h>
int main()
{
void* hello = dlopen("/home/lianxi/c++/ku/so/libhello.so", RTLD_LAZY);
if(!hello){
printf("dlopen /home/lianxi/c++/ku/so/libhello.so error!\n");
return -1;
}
dlerror();
CreatHelloClass* Creat_Hello = (CreatHelloClass*)dlsym(hello,"CreatHello");
const char* dlsym_error = dlerror();
if (dlsym_error) {
printf("error %s\n",dlsym_error);
return -1;
}
Hello_Base* mHello = Creat_Hello();
mHello->setctl(5);
int result = mHello->getctl(0);
printf("TK------>>>>>result is %d\n",result);
dlclose(hello);
return 1;
}
編譯:g++ -o test test.cpp -L. -ldl
執行./test結果:
[plain] view plain
在CODE上查看代碼片派生到我的代碼片
TK------>>>>>>Hello::Instance---------
TK------->>>>>>setctl-----
TK------->>>>>>getctl-----
TK------>>>>>result is 5
二、分析
1.libdl庫為C語言開發,當需要在C++中dlsym某個符號時、需要聲明庫中該符號為extern 「C」,比如例子中的extern "C" Hello_Base* CreatHello();
2.由於不可能像C語言那樣將C++類中的那麼多方法都dlsym出來,這里使用了C++中對於純虛類的實例化是運行時鏈接的特點;也就是說要在C++中對於類使用共享庫的動態鏈接、必須定義一個純虛的子類。

⑽ linux 用g++編譯c++代碼的問題

*

運行 gcc/egcs
*

gcc/egcs 的主要選項
*

gdb
*

gdb 的常用命令
*

gdb 使用範例
*

其他程序/庫工具 (ar, objmp, nm, size, strings, strip, ...)
* 創建和使用靜態庫
* 創建和使用共享庫
* 使用高級共享庫特性

1.7.1 運行 gcc/egcs

Linux 中最重要的軟體開發工具是 GCC。GCC 是 GNU 的 C 和 C++ 編譯器。實際上,GCC 能夠編譯三種語言:C、C++ 和 Object C(C 語言的一種面向對象擴展)。利用 gcc 命令可同時編譯並連接 C 和 C++ 源程序。

#DEMO#: hello.c

如果你有兩個或少數幾個 C 源文件,也可以方便地利用 GCC 編譯、連接並生成可執行文件。例如,假設你有兩個源文件 main.c 和 factorial.c 兩個源文件,現在要編譯生成一個計算階乘的程序。

-----------------------
清單 factorial.c
-----------------------
#include <stdio.h>
#include <stdlib.h>

int factorial (int n)
{
if (n <= 1)
return 1;

else
return factorial (n - 1) * n;
}
-----------------------

-----------------------
清單 main.c
-----------------------
#include <stdio.h>
#include <stdlib.h>

int factorial (int n);

int main (int argc, char **argv)
{
int n;

if (argc < 2) {
printf ("Usage: %s n\n", argv [0]);
return -1;
}
else {
n = atoi (argv[1]);
printf ("Factorial of %d is %d.\n", n, factorial (n));
}

return 0;
}
-----------------------

利用如下的命令可編譯生成可執行文件,並執行程序:
$ gcc -o factorial main.c factorial.c
$ ./factorial 5
Factorial of 5 is 120.

GCC 可同時用來編譯 C 程序和 C++ 程序。一般來說,C 編譯器通過源文件的後綴名來判斷是 C 程序還是 C++ 程序。在 Linux 中,C 源文件的後綴名為 .c,而 C++ 源文件的後綴名為 .C 或 .cpp。

但是,gcc 命令只能編譯 C++ 源文件,而不能自動和 C++ 程序使用的庫連接。因此,通常使用 g++ 命令來完成 C++ 程序的編譯和連接,該程序會自動調用 gcc 實現編譯。假設我們有一個如下的 C++ 源文件(hello.C):

#include <iostream.h>

void main (void)
{
cout << "Hello, world!" << endl;
}

則可以如下調用 g++ 命令編譯、連接並生成可執行文件:

$ g++ -o hello hello.C
$ ./hello
Hello, world!

1.7.2 gcc/egcs 的主要選項

表 1-3 gcc 命令的常用選項
選項 解釋
-ansi 只支持 ANSI 標準的 C 語法。這一選項將禁止 GNU C 的某些特色,
例如 asm 或 typeof 關鍵詞。
-c 只編譯並生成目標文件。
-DMACRO 以字元串「1」定義 MACRO 宏。
-DMACRO=DEFN 以字元串「DEFN」定義 MACRO 宏。
-E 只運行 C 預編譯器。
-g 生成調試信息。GNU 調試器可利用該信息。
-IDIRECTORY 指定額外的頭文件搜索路徑DIRECTORY。
-LDIRECTORY 指定額外的函數庫搜索路徑DIRECTORY。
-lLIBRARY 連接時搜索指定的函數庫LIBRARY。
-m486 針對 486 進行代碼優化。
-o FILE 生成指定的輸出文件。用在生成可執行文件時。
-O0 不進行優化處理。
-O 或 -O1 優化生成代碼。
-O2 進一步優化。
-O3 比 -O2 更進一步優化,包括 inline 函數。
-shared 生成共享目標文件。通常用在建立共享庫時。
-static 禁止使用共享連接。
-UMACRO 取消對 MACRO 宏的定義。
-w 不生成任何警告信息。
-Wall 生成所有警告信息。

#DEMO#

MiniGUI 的編譯選項
1.7.3 gdb

GNU 的調試器稱為 gdb,該程序是一個互動式工具,工作在字元模式。在 X Window 系統中,
有一個 gdb 的前端圖形工具,稱為 xxgdb。gdb 是功能強大的調試程序,可完成如下的調試
任務:
* 設置斷點;
* 監視程序變數的值;
* 程序的單步執行;
* 修改變數的值。
在可以使用 gdb 調試程序之前,必須使用 -g 選項編譯源文件。可在 makefile 中如下定義
CFLAGS 變數:
CFLAGS = -g
運行 gdb 調試程序時通常使用如下的命令:
gdb progname

在 gdb 提示符處鍵入help,將列出命令的分類,主要的分類有:
* aliases:命令別名
* breakpoints:斷點定義;
* data:數據查看;
* files:指定並查看文件;
* internals:維護命令;
* running:程序執行;
* stack:調用棧查看;
* statu:狀態查看;
* tracepoints:跟蹤程序執行。
鍵入 help 後跟命令的分類名,可獲得該類命令的詳細清單。

#DENO#
1.7.4 gdb 的常用命令

表 1-4 常用的 gdb 命令
命令 解釋
break NUM 在指定的行上設置斷點。
bt 顯示所有的調用棧幀。該命令可用來顯示函數的調用順序。
clear 刪除設置在特定源文件、特定行上的斷點。其用法為:clear FILENAME:NUM。
continue 繼續執行正在調試的程序。該命令用在程序由於處理信號或斷點而
導致停止運行時。
display EXPR 每次程序停止後顯示表達式的值。表達式由程序定義的變數組成。
file FILE 裝載指定的可執行文件進行調試。
help NAME 顯示指定命令的幫助信息。
info break 顯示當前斷點清單,包括到達斷點處的次數等。
info files 顯示被調試文件的詳細信息。
info func 顯示所有的函數名稱。
info local 顯示當函數中的局部變數信息。
info prog 顯示被調試程序的執行狀態。
info var 顯示所有的全局和靜態變數名稱。
kill 終止正被調試的程序。
list 顯示源代碼段。
make 在不退出 gdb 的情況下運行 make 工具。
next 在不單步執行進入其他函數的情況下,向前執行一行源代碼。
print EXPR 顯示表達式 EXPR 的值。

1.7.5 gdb 使用範例

-----------------
清單 一個有錯誤的 C 源程序 bugging.c
-----------------
#include <stdio.h>
#include <stdlib.h>

static char buff [256];
static char* string;
int main ()
{

printf ("Please input a string: ");
gets (string);

printf ("\nYour string is: %s\n", string);
}
-----------------
上面這個程序非常簡單,其目的是接受用戶的輸入,然後將用戶的輸入列印出來。該程序使用了
一個未經過初始化的字元串地址 string,因此,編譯並運行之後,將出現 Segment Fault 錯誤:
$ gcc -o test -g test.c
$ ./test
Please input a string: asfd
Segmentation fault (core mped)
為了查找該程序中出現的問題,我們利用 gdb,並按如下的步驟進行:
1.運行 gdb bugging 命令,裝入 bugging 可執行文件;
2.執行裝入的 bugging 命令;
3.使用 where 命令查看程序出錯的地方;
4.利用 list 命令查看調用 gets 函數附近的代碼;
5.唯一能夠導致 gets 函數出錯的因素就是變數 string。用 print 命令查看 string 的值;
6.在 gdb 中,我們可以直接修改變數的值,只要將 string 取一個合法的指針值就可以了,為
此,我們在第 11 行處設置斷點;
7.程序重新運行到第 11 行處停止,這時,我們可以用 set variable 命令修改 string 的取值;
8.然後繼續運行,將看到正確的程序運行結果。

#DEMO#

1.7.6 其他程序/庫工具

strip:

nm:

size:

string:

1.7.7 創建和使用靜態庫

創建一個靜態庫是相當簡單的。通常使用 ar 程序把一些目標文件(.o)組合在一起,成為一個單獨的庫,然後運行 ranlib,以給庫加入一些索引信息。

1.7.8 創建和使用共享庫

特殊的編譯和連接選項

-D_REENTRANT 使得預處理器符號 _REENTRANT 被定義,這個符號激活一些宏特性。
-fPIC 選項產生位置獨立的代碼。由於庫是在運行的時候被調入,因此這個
選項是必需的,因為在編譯的時候,裝入內存的地址還不知道。如果
不使用這個選項,庫文件可能不會正確運行。
-shared 選項告訴編譯器產生共享庫代碼。
-Wl,-soname -Wl 告訴編譯器將後面的參數傳遞到連接器。而 -soname 指定了
共享庫的 soname。

# 可以把庫文件拷貝到 /etc/ld.so.conf 中列舉出的任何目錄中,並以
root 身份運行 ldconfig;或者
# 運行 export LD_LIBRARY_PATH='pwd',它把當前路徑加到庫搜索路徑中去。

1.7.9 使用高級共享庫特性

1. ldd 工具

ldd 用來顯示執行文件需要哪些共享庫, 共享庫裝載管理器在哪裡找到了需要的共享庫.

2. soname

共享庫的一個非常重要的,也是非常難的概念是 soname——簡寫共享目標名(short for shared object name)。這是一個為共享庫(.so)文件而內嵌在控制數據中的名字。如前面提到的,每一個程序都有一個需要使用的庫的清單。這個清單的內容是一系列庫的 soname,如同 ldd 顯示的那樣,共享庫裝載器必須找到這個清單。

soname 的關鍵功能是它提供了兼容性的標准。當要升級系統中的一個庫時,並且新庫的 soname 和老的庫的 soname 一樣,用舊庫連接生成的程序,使用新的庫依然能正常運行。這個特性使得在 Linux 下,升級使用共享庫的程序和定位錯誤變得十分容易。

在 Linux 中,應用程序通過使用 soname,來指定所希望庫的版本。庫作者也可以通過保留或者改變 soname 來聲明,哪些版本是相互兼容的,這使得程序員擺脫了共享庫版本沖突問題的困擾。

查看/usr/local/lib 目錄,分析 MiniGUI 的共享庫文件之間的關系

3. 共享庫裝載器

當程序被調用的時候,Linux 共享庫裝載器(也被稱為動態連接器)也自動被調用。它的作用是保證程序所需要的所有適當版本的庫都被調入內存。共享庫裝載器名字是 ld.so 或者是 ld-linux.so,這取決於 Linux libc 的版本,它必須使用一點外部交互,才能完成自己的工作。然而它接受在環境變數和配置文件中的配置信息。

文件 /etc/ld.so.conf 定義了標准系統庫的路徑。共享庫裝載器把它作為搜索路徑。為了改變這個設置,必須以 root 身份運行 ldconfig 工具。這將更新 /etc/ls.so.cache 文件,這個文件其實是裝載器內部使用的文件之一。

可以使用許多環境變數控制共享庫裝載器的操作(表1-4+)。

表 1-4+ 共享庫裝載器環境變數
變數 含義
LD_AOUT_LIBRARY_PATH 除了不使用 a.out 二進制格式外,與 LD_LIBRARY_PATH 相同。
LD_AOUT_PRELOAD 除了不使用 a.out 二進制格式外,與 LD_PRELOAD 相同。
LD_KEEPDIR 只適用於 a.out 庫;忽略由它們指定的目錄。
LD_LIBRARY_PATH 將其他目錄加入庫搜索路徑。它的內容應該是由冒號
分隔的目錄列表,與可執行文件的 PATH 變數具有相同的格式。
如果調用設置用戶 ID 或者進程 ID 的程序,該變數被忽略。
LD_NOWARN 只適用於 a.out 庫;當改變版本號是,發出警告信息。
LD_PRELOAD 首先裝入用戶定義的庫,使得它們有機會覆蓋或者重新定義標准庫。
使用空格分開多個入口。對於設置用戶 ID 或者進程 ID 的程序,
只有被標記過的庫才被首先裝入。在 /etc/ld.so.perload 中指定
了全局版本號,該文件不遵守這個限制。

4. 使用 dlopen

另外一個強大的庫函數是 dlopen()。該函數將打開一個新庫,並把它裝入內存。該函數主要用來載入庫中的符號,這些符號在編譯的時候是不知道的。比如 Apache Web 伺服器利用這個函數在運行過程中載入模塊,這為它提供了額外的能力。一個配置文件控制了載入模塊的過程。這種機制使得在系統中添加或者刪除一個模塊時,都不需要重新編譯了。

可以在自己的程序中使用 dlopen()。dlopen() 在 dlfcn.h 中定義,並在 dl 庫中實現。它需要兩個參數:一個文件名和一個標志。文件名可以是我們學習過的庫中的 soname。標志指明是否立刻計算庫的依賴性。如果設置為 RTLD_NOW 的話,則立刻計算;如果設置的是 RTLD_LAZY,則在需要的時候才計算。另外,可以指定 RTLD_GLOBAL,它使得那些在以後才載入的庫可以獲得其中的符號。

當庫被裝入後,可以把 dlopen() 返回的句柄作為給 dlsym() 的第一個參數,以獲得符號在庫中的地址。使用這個地址,就可以獲得庫中特定函數的指針,並且調用裝載庫中的相應函數。