C/C++库文件全了解（包含静态库、动态库，包含windows、linux，包含dll、lib、so）

落日映苍穹つ 2022-03-15 07:22 824阅读 0赞

### 目录 ###

*  C/C++库文件全了解
 *   *  一. 前言
     *  二. 名词解释
     *   *  2.1. windows的静态库：xxx.lib
         *  2.2. windows的动态库：xxx.dll
         *  2.3. linux的动态库：libxxx.so
         *  2.4. linux的静态库：libxxx.a
     *  三. 自己编译库
     *   *  3.1 编译产生windows的静态库
         *  3.2 编译产生windows的动态库
         *  3.3 编译产生linux的静态库
         *  3.4 编译产生linux的动态库
     *  四. 自己调用库
     *   *  4.1. 调用windows静态库文件
         *  4.2. 调用windows动态库文件
         *  4.3. 调用linux静态库文件
         *  4.4. 调用linux动态库文件

# C/C++库文件全了解 #

*  ## 一. 前言 ##
    
    是不是老是在编译的过程出现各种奇奇怪怪的错误，对于出现的错误完全看不懂 在说点啥，只会复制黏贴到百度一通瞎搜索？是不是对于一些库文件.dll，.so，.lib完全不知道是个啥，完全不知道怎么使用他们？这是因为我们对一个C/C++程序的编译过程不够了解。关于编译过程的概念我放到了我的思维导图，[链接][Link 1]，这里不再赘述。本文旨在带你了解库文件的编译生成和调用。
 *  ## 二. 名词解释 ##
    
     *  ### 2.1. windows的静态库：xxx.lib ###
        
        包含testlib.lib和testlib.h两个文件，在写程序调用静态库里包含的函数的时候，编译完就已经把函数的实现放到了产生的exe文件里了，所以exe后期的运行不需要依赖静态库了，代价就是exe体积会变大。目前主流程序一般不用静态库
     *  ### 2.2. windows的动态库：xxx.dll ###
        
        包含testlib.lib和testlib.dll两个文件，在写程序调用动态库里包含的函数的时候，编译阶段只把函数的重定位信息放到了exe文件里了，所以exe后期的运行需要依赖动态库。值得一提的是，虽然动态库和静态库都有一个.lib文件，但是两者完全不一样。动态库的.lib文件只在你调用的编译阶段需要，而.dll只在调用的运行阶段需要。
     *  ### 2.3. linux的动态库：libxxx.so ###
        
        概念和windows的动态库一样，就是linux下的静态库和动态库命名时都需要在前面加lib
     *  ### 2.4. linux的静态库：libxxx.a ###
 *  ## 三. 自己编译库 ##
    
     *  ### 3.1 编译产生windows的静态库 ###
        
         *  **3.1.1代码准备：**  
            C:\\Users\\john\\Desktop\\static\_lib:  
            ├─static\_lib.cpp  
            ├─static\_lib.h  
            ├─pch.cpp \#这两个是vc++自己产生的的预编译头，这里我们不关注  
            └─pch.h \#这两个是vc++自己产生的的预编译头，这里我们不关注
         *  **3.1.2 static\_lib.cpp:**
            
                #include "pch.h"
                #include "static_lib.h"
                int add(int x, int y)
                { 
                	return x + y;
                }
         *  **3.1.3 static\_lib.h：**
            
                #pragma once
                int add(int x, int y);
            
            编译完成后得到DEBUG文件夹里得到static\_lib.lib文件，另外加一个刚才用的static\_lib.h，有这两个文件就可以调用函数add了，调用过程在后面。
     *  ### 3.2 编译产生windows的动态库 ###
        
         *  **3.2.1代码准备：**  
            C:\\Users\\john\\Desktop\\dynamic\_lib:  
            ├─dynamic\_lib.cpp  
            ├─dynamic\_lib.h  
            ├─pch.cpp \#这两个是vc++自己产生的的预编译头，这里我们不关注  
            └─pch.h \#这两个是vc++自己产生的的预编译头，这里我们不关注
         *  **3.2.2 dynamic\_lib.cpp：**
            
                #include "pch.h"
                #include "dynamic_lib.h"
                #define DLL_API _declspec(dllexport)
                DLL_API int add(int a, int b)   //实现两个整数相加
                { 
                	return a + b;
                }
         *  **3.2.3 dynamic\_lib.h：**
            
                #pragma once
                #define DLL_API _declspec(dllexport)
                int add(int x, int y);
        
        编译完在DEBUG里会产生dynamic\_lib.dll和dynamic\_lib.lib两个文件
     *  ### 3.3 编译产生linux的静态库 ###
        
         *  **3.3.1代码准备：**  
            /home/nvidia/DeepLearning/test\_a:  
            ├─static\_lib.c  
            └─static\_lib.h
         *  **3.3.2 static\_lib.c：**
            
                #include "static_lib.h"
                int add(int a, int b)
                { 
                	int c;
                	c = a + b;
                	return c ;
                }
         *  **3.3.3 static\_lib.h:**
            
                #pragma onece
                int add(int a, int b);
         *  **3.3.4 编译生成静态库:**  
            编译过程分两步，先生成.o文件，然后根据.o文件归档为.a静态库文件
            
                gcc -c static_lib.c
            
            然后归档为静态库文件，这样就生成了静态库libstatic\_lib.a
            
                ar crv libstatic_lib.a static_lib.o
     *  ### 3.4 编译产生linux的动态库 ###
        
         *  **3.4.1代码准备：**  
            /home/nvidia/DeepLearning/test\_so:  
            ├─dynamic\_lib.c  
            └─dynamic\_lib.h
         *  **3.4.2 dynamic\_lib.c：**
            
                #include "dynamic_lib.h"
                int add(int a, int b)
                { 
                	int c;
                	c = a + b;
                	return c ;
                }
         *  **3.4.3 dynamic\_lib.h:**
            
                #pragma onece
                int add(int a, int b);
        
        编译产生.so文件，命令行里输入
        
            nvidia@tegra-ubuntu:~$ gcc dynamic_lib.c -shared -fPIC -o libdynamic_lib.so
        
        要注意的是，一般产生的.so文件名要以lib开头
 *  ## 四. 自己调用库 ##
    
     *  ### 4.1. 调用windows静态库文件 ###
        
         *  **4.1.1代码准备：**  
            C:\\Users\\john\\Desktop\\lib\_test:  
            ├─lib\_test.cpp  
            └─stdafx.h \#这是vc++自己产生的的预编译头，这里我们不关注
         *  **4.1.2 lib\_test.cpp:**
            
                #include "stdafx.h"
                #include "static_lib.h"
                #pragma comment(lib, "static_lib.lib")
                int _tmain(int argc, _TCHAR* argv[])
                { 
                	int a = 0, b = 2, c;
                	c = add(a, b);
                	return 0;
                }
        
        这里需要设置编译器，告诉编译器静态库叫什么名字，在哪个文件夹里。在VS里需要设置地方是项目—属性—VC++ 目录，将static\_lib.h所在的路径C:\\Users\\john\\Desktop\\static\_lib填到包含目录里，将之前生成的static\_lib.lib所在路径C:\\Users\\john\\Desktop\\static\_lib\\DEBUG填到库目录里。然后在项目——属性—链接器—输入，将static\_lib.lib输入到附加依赖项里（这一步其实等同于lib\_test.cpp里的\#pragma comment(lib, “static.lib”)这句话，两者二选一即可）。最后编译成功。
     *  ### 4.2. 调用windows动态库文件 ###
        
         *  **4.2.1代码准备：**  
            C:\\Users\\john\\Desktop\\lib\_test:  
            ├─lib\_test.cpp  
            └─stdafx.h \#这是vc++自己产生的的预编译头，这里我们不关注
         *  **4.2.2 lib\_test.cpp:**
            
                #include "stdafx.h"
                #pragma comment(lib, "dynamic_lib.lib")
                extern int add(int a, int b);
                int _tmain(int argc, _TCHAR* argv[])
                { 
                	int a = 0, b = 2, c;
                	c = add(a, b);
                	return 0;
                }
        
        注意，这里代码中少了一个include，多了一个extern了。在VS里需要设置地方是项目—属性—VC++ 目录，将之前生成的dynamic\_lib.lib所在路径C:\\Users\\john\\Desktop\\dynamic\_lib\\DEBUG填到库目录里。然后在项目——属性—链接器—输入，将dynamic\_lib.lib输入到附加依赖项里（这一步其实等同于lib\_test.cpp里的\#pragma comment(lib, “static.lib”)这句话，两者二选一即可）。最后编译成功。运行的时候需要把.dll文件放到生成exe的文件夹里，不然编译成功运行会出错
     *  ### 4.3. 调用linux静态库文件 ###
        
         *  **4.3.1代码准备：**  
            /home/nvidia/DeepLearning/lib\_test:  
            └─lib\_test.c
         *  **4.3.2 lib\_test.c:**
            
                #include "static_lib.h"
                int main()
                { 
                    int a = 0, b = 2, c;
                    c = add(a, b);
                    return 0;
                }
         *  **4.3.3 编译:**
            
                gcc lib_test.c -o lib_test -L ../static_lib/ -lstatic_lib -I ../static_lib/
        
        注意，这里编译的时候需要用-I（大写的i）指定头文件所在文件夹位置，用-L指定动态库所在文件夹，用-l（小写的L）指定动态库的名字（去掉名字里最前面的lib）
        
         *  **4.3.4 运行即可成功**
     *  ### 4.4. 调用linux动态库文件 ###
        
         *  **4.4.1代码准备：**  
            /home/nvidia/DeepLearning/lib\_test:  
            └─lib\_test.c
         *  **4.4.2 lib\_test.c:**
            
                #include "dynamic_lib.h"
                int main()
                { 
                    int a = 0, b = 2, c;
                    c = add(a, b);
                    return 0;
                }
         *  **4.4.3 编译:**
            
                gcc lib_test.c -o lib_test -L ../dynamic_lib/ -ldynamic_lib -I ../dynamic_lib/
        
        注意，这里编译的时候需要用-I（大写的i）指定头文件所在文件夹位置，用-L指定动态库所在文件夹，用-l（小写的L）指定动态库的名字（去掉名字里最前面的lib）
        
         *  **4.4.3 运行报错:**  
            直接输入`./lib_test`运行会报错。因为刚才编译的时候可以通过编译参数告诉编译器动态库的位置，但是运行的时候不知道动态库在哪。
        
            ./lib_test: error while loading shared libraries: libdynamic_lib.so: cannot open shared object file: No such file or directory
        
        通过ldd命令可以查看lib\_test需要哪些动态库，可以看到我们的动态库他找不到  
        `bash huangshiqing@ezviz-W580-G20:~/lib_test$ ldd lib_test linux-vdso.so.1 => (0x00007ffd659e0000) libdynamic_lib.so => not found libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f0a01391000) /lib64/ld-linux-x86-64.so.2 (0x00007f0a0175b000)`
        
         *  **4.4.4 指定动态库搜索路径:**  
            动态链接时、执行时搜索路径顺序:
    
    1.  编译目标代码时指定的动态库搜索路径；  
        只在编译环节可以通过命令参数指定
    2.  环境变量LD\_LIBRARY\_PATH指定的动态库搜索路径；  
        通过下面命令临时添加或者在.bashrc中永久添加
        
            export LD_LIBRARY_PATH=/home/nvidia/DeepLearning/dynamic_lib/:$LD_LIBRARY_PATH
    3.  配置文件/etc/ld.so.conf中指定的动态库搜索路径；  
        [概念参见这里][Link 2]
    4.  默认的动态库搜索路径/lib；  
        直接将动态库移到这两个默认会去搜索的路径也可以
    5.  默认的动态库搜索路径/usr/lib。
    
     *  **4.4.5 指定动态库位置后再次运行即成功**
    
    参考链接：https://blog.csdn.net/sunxiaopengsun/article/details/79351025

[Link 1]: https://www.processon.com/view/link/5c70f497e4b0feef9f352ea2
[Link 2]: https://www.cnblogs.com/chris-cp/p/3591306.html