C标准库和C++的STL是共享元件的例子，可以被我们的程序所链接。这样的好处是：每个对象文件在链接时不需要被陈述，因为开发者可以批量引用库。这简化了应用之间的元素共享和重复利用。
库类型
- 静态库（.a）
- 动态库（.so）：这种类型的库只有一种形式，但是有两种使用方式：
- 在运行时动态链接： 这种库必须在编译/链接阶段可用。 这些共享的对象并不被包含到可执行元件中去，但被绑定到可执行程序。
- 动态加载/卸载，在执行时链接（例如：浏览器插件）。
库命名传统： 通常带有
lib前缀，所有C标准库都是满足这样的规律。当链接时，命令行引用这个库时将不包含前缀或者后缀；例如，gcc src-file.c -lm -lpthread这个编译、链接命令，在链接过程中引用的库是数学库m和线程库pthread，这两个库可以在/usr/lib/libm.a和/usr/lib/libpthread.a找到。注意：GNU编译器现在有命令行-pthread选项，而老版本的编译器需要通过-lpthread显式指定线程库。因此，你更有可能看到gcc src-file.c -lm -pthread。
静态库（.a）
命令：cc -Wall -c ctest1.c ctest2.c
- 选项
-Wall：包含警告，可以看到警告的帮助页 - 创建一个
libctest.a库：ar -cvq libctest.a ctest1.o ctest2.o - 列出库所包含的文件：
ar -t libctest.a - 链接这个库：
- cc -o exe prog.c libctest.a
- cc -o exe prog.c -L/path/to/library-dir -lctest
注意：当创建库以后，通过命令行链接并生成可执行程序以后，会在可执行程序的archive中创建一个符号表，可执行程序就嵌入了ar命令，对于MS/Windows开发者来说，.a库和Visual C++的.lib库一样。
动态链接的共享对象库（.so）
生成一个共享库方法：（动态链接对象库文件）
- 创建一个对象代码
- 创建库
- 可选：使用符号链接创建默认版本
创建库实例
gcc -Wall -fPIC -c *.cgcc -shared -W1,-soname,libctest.so.1 -o libctest.so.1.0 *.omv libctest.so.1.o /opt/libln -sf /opt/lib/libctest.so.1.0 /opt/lib/libctest.so.1ln -sf /opt/lib/libctest.so.1.0 /opt/lib/libctest.so
这会创建一个libctest.so.1.o和一个指向它的符号链接。将链接级联也是合法的：
ln -sf /opt/lib/libctest.so.1.0 /opt/lib/libctest.so.1ln -sf /opt/lib/libctest.so.1 /opt/lib/libctest.so
如果查看/lib和/usr/lib下的所有库，以上两种方法都存在，linux开发者并没有统一。重要的是符号链接最终指向的真实库文件。
-Wall： 包含警告； -fPIC：编译器输出独立代码位置，共享库需要的一个特点； -shared：产生一个共享库对象，可以被其他对象链接形成一个可执行程序； -Wl：可选，传递选项给链接器；在上面的例子里，“-soname libctest.so.1被传递； -o：运算输出，共享对象的名字为libctest.so.1.0` 库的链接：
- 链接/opt/lib/libctest.so 允许编译
-lctest执行； - 链接/opt/lib/libctest.so.a`允许运行时绑定运行；
编译main程序并链接共享对象库
gcc -Wall -I/path/to/include-flies -L/path/to/libraries prog.c -lctest -o prog
gcc -Wall -L/opt/lib prog.c -lctest -o prog 共享库的名字是libctest.so，这就是为什么你需要创建符号链接，否则你会得到/usr/bin/ld:cannot find -lctest 错误。这些库不会被包含到可执行程序中，在运行过程中动态链接。 依赖列表
可执行程序依赖的共享库可以通过`ldd name-of-executable列举出来，当库被加载时，共享连接库中未解析错误可能会导致程序运行错误。
例如，[prompt]$ ldd libname-of-lib.so libglut.so.3 => /usr/lib64/libglut.so.3 (0x00007fb582b74000) libGL.so.1 => /usr/lib64/libGL.so.1 (0x00007fb582857000) libX11.so.6 => /usr/lib64/libX11.so.6 (0x00007fb582518000) libIL.so.1 (0x00007fa0f2c0f000) libcudart.so.4 => not found
前三个库表明存在路径，而后两个存在问题。解决后两个库的依赖：
- 方法一：添加为解析库的路径到/etc/ld.so.conf.d/name-of-lib-x86_64.conf 和/或 /etc/ld.so.conf.d/name-of-lib-i686.conf，然后用
sodu ldconfig再加载库缓存 - 方法二：添加库库和路径到编译/链接命令: -lname-of-lib -L/path/to/lib
- 方法三：添加库路径到环境变量解决运行依赖问题：export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/path/to/lib
运行程序
- 设置路径: export LD_LIBRARY_PATH=/opt/lib:$LD_LIBRARY_PATH
- 运行：prog
主要名词：
- gcc -GNU的c编译器
- ld -GNU的链接器
- ldd -列出库的依赖项
- ldconfig -配置动态链接器运行时绑定对象（即，更新缓存/etc/ld.so.cache）
库路径
为了让可执行程序找到需要的库，并在运行时链接，必须对系统进行一些配置，相关的配置方法有以下：
- 添加在动态链接时需要包含的库目录到/etc/ld.so.conf文件中，执行ldconfig（root权限）配置链接器在运行时的绑定对象。你可以使用
-f file-name标识引用其他配置文件。 - 添加指定目录到库缓存： ldconfig -n /opt/lib。其中，/opt/lib是包含你的库ctest.so的目录，但这种方式不会对系统永久生效，重启后会丢失。例如，当前目录
ldconfig -n .，链接使用-L.即可。 - 指定环境变量LD_LIBRARY_PATH，使其包含共享库所在的目录。export LD_LIBRARY_PATH=/OPT/LIB:$LD_LIBRARY_PATH，或者编辑~/.bashrc文件：
...if [ -d /opt/lib ];then LD_LIBRARY_PATH=/opt/lib:$LD_LIBRARY_PATHfi...export LD_LIBRARY_PATH
库信息
ar：列举在archive库中的所有对象文件
ar tf /usr/lib/x86_64-linux-gnu/libjpeg.a nm：列举符号，包括对象文件、archive库和共享库
nm file.o #列举对象文件中包含的符号nm /usr/lib/x86_64-linux-gnu/libjpeg.a #列举包含在archive库中的符号。 使用-D列巨额包含在对象文件或共享库中的符号。 使用libdl动态加载和卸载共享库
在执行时可以动态加载/卸载这些库。
库的包含文件ctest.h如下所示：使用extern "c"方便该库可以用在c和c++里。这个语句可以防止链接时因为C++的名字隔离而导致的为解析符号。 #ifndef CTEST_H#define CTEST_H#ifdef __cplusplusextern "C" {#endifvoid ctest1(int *);void ctest2(int *);#ifdef __cplusplus}#endif#endif 动态加载或卸载libctest.so库(progdl.c)：
#include#include #include "ctest.h"int main(int argc, char **argv) { void *lib_handle; double (*fn)(int *); int x; char *error; lib_handle = dlopen("/opt/lib/libctest.so", RTLD_LAZY); if (!lib_handle) { fprintf(stderr, "%s\n", dlerror()); exit(1); } fn = dlsym(lib_handle, "ctest1"); if ((error = dlerror()) != NULL) { fprintf(stderr, "%s\n", error); exit(1); } (*fn)(&x); printf("Valx=%d\n",x); dlclose(lib_handle); return 0;}
编译命令：gcc -rdynamic -o progdl progdl.c -ldl
解释：
- dlopen("/opt/lib/libctest.so", RTLD_LAZY);打开名字为”libctest.so“的共享连接库，第二个参数显示绑定，在dlfcn.h文件中定义，如果失败了返回NULL。 选项： RTLD_LAZY:如果指定，linux并不关心未解析符号直到被引用；RTLD_NOW：所有未解析符号都会被解析在调用dlopen时；RT_GLOBAL,让符号库可见。
- dlsym(lib_handle, "ctest1"); 换回加载的共享库的函数地址；如果失败返回值为NULL。注意：当使用c++函数时，首先使用nm找到mangles符号名字，或者使用extern "C"避免名字mangling. 例如，extern "C" void function-name();
C++类对象和动态加载
C++和名字修饰（name mangling）
当使用c++编译上面的c例子，会发现c++函数名字被修饰而导致不可用，除非函数定义有extern "C"{}保护。
//1:extern "C" { int functionx();}//2:extern "C" int functionx(); 以下两者是等价的：
//1:extern "C" { extern int functionx();}//2:extern "C" int functionx(); 动态加载C++类：
动态库加载程序可以使得编程者加载C函数。在C++中，我们想要加载类的成员函数，实际上，整个类可以在库中，我们先要加载并访问整个对象以及它的成员函数。通过传递”C“类工厂函数可以实现。 类的头文件如下所示：class Abc {......};// Class factory "C" functionstypedef Abc* create_t;typedef void destroy_t(Abc*); 对应的cpp文件如下：
Abc::Abc(){ ...}extern "C"{ // These two "C" functions manage the creation and destruction of the class Abc Abc* create() { return new Abc; } void destroy(Abc* p) { delete p; // Can use a base class or derived class pointer here }} 这个cpp文件是库的源文件，C函数在库中动态加载库中实例化、销毁一个类，Abc就是这个类。
包含Main可执行程序调用这个库的方法如下：
// load the symbols create_t* create_abc = (create_t*) dlsym(lib_handle, "create");...... destroy_t* destroy_abc = (destroy_t*) dlsym(lib_handle, "destroy");......
注意： C++类的new/delete应该都由可执行程序或者库来提供，不应该分开。以便如果在一方出现了new/delete的重载不会导致意外情况。
和DLL的比较
windows下和linux/Unix共享对象(.so)对应的是.dll，通常windows下是.dll，有时也可能是.ocx。 在旧的16位系统上，动态链接库也可能为.exe。不幸的是，windows下Dll的生成和Microsoft IDE紧密结合，没有IDE基本没有办法自己生成。
windows c++对应的函数：- ::LoadLibrary() - dlopen()
- ::GetProcAddress() -dlsym()
- ::FreeLibrary() -dlclose()
跨平台代码片段
包含头文件(.h/.hpp)：
class Abc{public: static Abc* Instance(); // Function declaration. Could also be used as a public class member function.private: static Abc *mInstance; // Singleton. Use this declaration in C++ class member variable declaration. ...} 对应的cpp文件：
/// Singleton instantiationAbc* Abc::mInstance = 0; // Use this declaration for C++ class member variable // (Defined outside of class definition in ".cpp" file)// Return unique pointer to instance of Abc or create it if it does not exist.// (Unique to both exe and dll)static Abc* Abc::Instance() // Singleton{#ifdef WIN32 // If pointer to instance of Abc exists (true) then return instance pointer else look for // instance pointer in memory mapped pointer. If the instance pointer does not exist in // memory mapped pointer, return a newly created pointer to an instance of Abc. return mInstance ? mInstance : (mInstance = (Abc*) MemoryMappedPointers::getPointer("Abc")) ? mInstance : (mInstance = (Abc*) MemoryMappedPointers::createEntry("Abc",(void*)new Abc));#else // If pointer to instance of Abc exists (true) then return instance pointer // else return a newly created pointer to an instance of Abc. return mInstance ? mInstance : (mInstance = new Abc);#endif} windows链接器将会链接入两个对象实例，一个在exe，一个在可加载模块内。通过内存映射指针可对两者进行明确，以便exe和可加载库指向同一个变量或者对象。而GNU 链接器不存在这个问题。
交叉平台可加载库的编程：#ifndef USE_PRECOMPILED_HEADERS#ifdef WIN32#include#include #else#include #include #endif#include #endif using namespace std;#ifdef WIN32 HINSTANCE lib_handle;#else void *lib_handle;#endif // Where retType is the pointer to a return type of the function // This return type can be int, float, double, etc or a struct or class. typedef retType* func_t; // load the library -------------------------------------------------#ifdef WIN32 string nameOfLibToLoad("C:\opt\lib\libctest.dll"); lib_handle = LoadLibrary(TEXT(nameOfLibToLoad.c_str())); if (!lib_handle) { cerr << "Cannot load library: " << TEXT(nameOfDllToLoad.c_str()) << endl; }#else string nameOfLibToLoad("/opt/lib/libctest.so"); lib_handle = dlopen(nameOfLibToLoad.c_str(), RTLD_LAZY); if (!lib_handle) { cerr << "Cannot load library: " << dlerror() << endl; }#endif......... // load the symbols -------------------------------------------------#ifdef WIN32 func_t* fn_handle = (func_t*) GetProcAddress(lib_handle, "superfunctionx"); if (!fn_handle) { cerr << "Cannot load symbol superfunctionx: " << GetLastError() << endl; }#else // reset errors dlerror(); // load the symbols (handle to function "superfunctionx") func_t* fn_handle= (func_t*) dlsym(lib_handle, "superfunctionx"); const char* dlsym_error = dlerror(); if (dlsym_error) { cerr << "Cannot load symbol superfunctionx: " << dlsym_error << endl; }#endif......... // unload the library -----------------------------------------------#ifdef WIN32 FreeLibrary(lib_handle);#else dlclose(lib_handle);#endif