精华内容
下载资源
问答
  • 动态库和静态库

    2015-06-12 16:40:47
    ## 动态库和静态库小结 ## 动态库和静态库是编程过程中经常用到的两个东西,不同的背景下使用不同的方式,为了达到更好的目的。用途 动态库和静态库都是用来封装相同类型作用的函数,以便用来自己或第三方使用的...
    ## 动态库和静态库小结 ##
    动态库和静态库是编程过程中经常用到的两个东西,不同的背景下使用不同的方式,为了达到更好的目的。
    
    1. 用途
      动态库和静态库都是用来封装相同类型作用的函数,以便用来自己或第三方使用的代码库。

    2. 静态库和动态库
      静态库:lib后缀叫做静态库,静态库中包含执行代码、符号表等信息。
      动态库:dll后缀叫做动态库,动态库编译生成的lib后缀文件叫导入库,导入库包含地址符号、地址信息,为了根据地址信息找到具体实现。

    3. 调用
      静态库调用需要文件
      动态库调用需要文件

    4. vs使用
      A 静态库
      (1)项目属性,链接器->输入->附加依赖项增加lib文件。或者代码中加入

      
      #pragma comment(lib, “Test.lib”)
      

      (2)加入相应的头文件

      B 动态库
      (1)隐式调用(静态调用)
      项目属性,链接器->输入->附加依赖项增加lib文件。或者代码中加入

      
      #pragma comment(lib, “Test.lib”)    
      

      加入相应的头文件。
      (2)显示调用(动态调用)
      使用函数指针和WIN32 API函数LoadLibrary、GetProcAddress等加载动态库。不需要使用lib和头文件。

    5. 加载
      静态库:程序编译时静态库已被加载进来,程序运行时不需要此文件,程序的体积大。
      动态库:程序运行时被加载进来,程序运行时需要此文件,程序的体积小。而且系统中此动态库被加载一次,多个应用程序使用。节省内存使用。

    6. 后期更新
      静态库:修改具体功能实现之后,需要重新编译应用程序才可以。
      动态库:编译动态库之后,可直接替换原来的即可,不需要重新编译应用程序。

    展开全文
  • Linux制作动态库和静态库 命名规则 静态库命名规则如下: libxxx.o lib:前缀 .o:静态库 动态链接库(shared object file,共享对象文件)命名规则如下: libxxx.so lib:前缀 .so:动态库 动态库...

    参考链接

    GCC生成动态链接库(.so文件):-shared和-fPIC选项
    GCC创建和使用静态链接库(.a文件)
    gcc的使用方法;动态编译和静态编译;Linux制作动态库和静态库

    命名规则

    静态库命名规则如下:
    libxxx.o
    lib:前缀
    .o:静态库
    动态链接库(shared object file,共享对象文件)命名规则如下:
    libxxx.so
    lib:前缀
    .so:动态库

    静态库参数

    在这里插入图片描述

    gcc 常用编译选项

    在这里插入图片描述

    动态库和静态库的对比

    我们先来说一下静态库;
    Linux下的静态库是以.a结尾的二进制文件,它作为一个程序的模块,它在链接期间就被组合到了程序中,比如说我有一个主程序mian.c,那么我把它和静态库链接的时候,它就直接把这个静态库组合到了我的main.c里面生成的一个二进制文件.a。
    而与静态链接库相对的是动态链接库,同样的是把主函数mian.c和动态库进行链接,与静态库不同的是,这个动态库在程序运行的阶段才会被加载进内存,参与主函数运行
    下面用几张图来说明一下:
    在这里插入图片描述
    在这里插入图片描述

    还可以加上-static选项,让链接静态库后的math.out彻底的独立起来,“完全静态”,因此,得到的二进制文件会非常大。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    使用静态/动态链接库的优缺点:

    静态库:

    编译后的执行程序不需要外部的函数库支持,因为所有使用的函数都经被编译进去了。当然这也会成为他的缺点,因为如果静态函数库改变了,那么你的程序必须重新编译
    静态库的代码在编译时链接到应用程序中,因此编译时库文件必须存在并且需要通过“-L”参数传递给编译器,应用程序在开始执行时库函数代码将随程序一 起调入进程内存段直到进程结束,其执行过程不需要原静态库存在。

    动态库:

    动态函数库在编译的时候并没有被编译进目标代码中,你的程序执行到相关函数时才调用该函数库里的相应函数,因此动态函数库所产生的可执行文件比较。由于函数库没有被整合进你的程序,而是程序运行时动态的申请并调用,所以程序的运行环境中必须提供相应的库。动态函数库的改变并不影响你的程序,所以动态函数库的升级比较方便
    不同的INIX系统链接动态库方法,实现细节不一样,编译PIC型.o中间文件的方法一般是采用C语言编译器的-KPIC或者 -fPIC选项
    最主要的是GCC命令行的一个选项:
    -shared:该选项指定生成动态连接库(让连接器生成T类型的导出符号表,有时候也生成弱连接W类
    型的导出符号) ,不用该标志外部程序无法连接。相当于一个可执行文件
    -fPIC:表示编译为位置独立的代码,不用此选项的话编译后的代码是位置相关的,所以动态载入时是通过代码拷贝的方式来满足不同进程的需要,而不能达到真正代码段共享的目的。

    制作链接库的目的(商业角度):

    这就和商业项目挂钩了:
    假如我们是一个项目的外包方,我们是有专利的,希望别人使用我们已经实现的功能,但又不希望别人看到我们的源代码,所以这对商业机构是非常友好的。

    Makefile中的使用实例:

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 动态库和静态库

    2009-09-15 11:59:00
    一、静态库1. 如何创建静态库(以VS2005为例) 创建一个项目命名为StaticLib,项目设置(VC2005.Net):Project-Property-Configuration Properties - General - Project Defaults - Configuration Type 选择 Static ...

    一、静态库

    1. 如何创建静态库(以VS2005为例)

         创建一个项目命名为StaticLib,项目设置(VC2005.Net):
    Project-Property-Configuration Properties - General - Project Defaults - Configuration Type 选择 Static Library(.lib)

    1. //代码示例   
    2. //StaticLib.h   
    3. #pragma once   
    4. #ifdef __cplusplus   
    5. extern "C" {   
    6. #endif   
    7.   
    8.     int Add(int a, int b);   
    9.   
    10. #ifdef __cplusplus   
    11. }   
    12. #endif   
    13.   
    14. //StaticLib.cpp   
    15. #include "StaticLib.h"   
    16. int Add(int a, int b)   
    17. {   
    18.     return a+b;
    19. }   

    2. 如何连接静态库

        使用静态库需要加载静态库的。lib文件以及包含。h文件,具体步骤如下:

    1)在连接器中加载静态库,有两种加载方式:

         a。项目设置中引用.lib,Project-Property-Configuration Properties-link-Input-Additional Dependencies中添加.lib;

         b.  在代码使用 #progma comment(lib,"lib文件名");

    2)在使用该静态库的文件头包含静态库的。h文件

     

    3. 如何使用静态库

      创建一个控制台程序,用于测试静态库.  
      //main.cpp  
      #include "../UseLib/UseLib.h"               //这是包含.h.请更改为你的.h路径.  
      #pragma comment(lib, "../lib/UseLib.lib")   //这是包含.lib.请更改为你的.lib路径.  
      int main(int argc, char* argv[])  
     {  
        int a = 11, b = 12, c = 0;  
     
        c = Add(a, b);  
        return 0;  
     } 

     

    二、动态库

    1. 如何创建动态库(以VS2005为例)

     

         创建一个项目命名为DynamicLib,项目设置(VC2005.Net):
    Project-Property-Configuration Properties - General - Project Defaults - Configuration Type 选择 Dynamic Library (.dll)

    //DynamicLib.h    #ifdef _USRDLL    #define DllAPI extern "C" __declspec(dllexport)    #else   #define DllAPI extern "C" __declspec(dllimport)    #endif    DllAPI int Add(int a, int b);     //UseDll.cpp    #include "DynamicLib.h"       DllAPI int Add(int a, int b)    {        return a+b; }      

    2. 如何连接动态库

        链接动态库有两种方式:

    1)隐式链接:同使用静态库相似,分为三步:包含.h和引用.lib,使用导出函数;这种方法是在程序运行开始就将dll库载入内存, 所以如果

         程序运行时找不到dll文件将导致程序启动失败;

    2)显式链接:直接使用LoadLibrary 加载所需的动态库,然后指定所需的导出函数. 这种方法不需要动态链接库的.h和.lib文件.

         LoadLibrary函数映射DLL文件映像到进程地址空间, 失败返回NULL,通过GetLastError()可以获得相关错误.
               GetProcAddress函数使用函数名字取得函数的地址。利用该函数地址,就可以访问动态连接库的函数了。返回NULL表示获取失

        败.通过GetLastError()可以获得相关错误.
              FreeLibrary通过检查动态连接库的引用计数器,判断是否还有别的程序在使用这个动态连接库。如果没有,就从内存中移去该动态

         连接 库;如果有,将动态连接库的使用计数器减1。LoadLibrary则将引用计数加1

     

    3. 如何使用动态库

      创建一个控制台程序,用于测试动态库

      //main.cpp  
    #include "windows.h"  
    #include <stdio.h>  
     
    //1表示使用隐式链接.  
    //0表示使用显式链接.  
    #define StaticLink  0  
     
    #if StaticLink  
    #include "../DynamicLib/DynamicLib.h"                   //这是包含.h.请更改为你的.h路径.  
    #pragma comment(lib,"../lib/DynamicLib.lib")     //这是包含.lib.请更改为你的.lib路径.  
    #endif  
     
    int main(int argc, char* argv[])  
    {  
        int a = 11, b = 12, c = 0;  
     
    #if StaticLink  
        c = GetMin(a,b);  
        /* 
        使用隐式链接注意事项,需要把.dll放到系统能找到的地方.下面加载dll的搜索顺序:     
        1) 包含可执行映像文件的目录。 
        2) 进程的当前目录。 
        3) Windows系统目录。 
        4) Windows目录。 
        5) PATH环境变量中列出的各个目录。 
        */ 
    #else  
        typedef int  (*LPFNDLLFUNC)(int ,int);  
        LPFNDLLFUNC lpfnDllFunc;   
     
        HINSTANCE hInst = LoadLibrary("../lib/DynamicLib.dll"); //请更改为你的.dll路径.  
     
        if (hInst == NULL)  
        {  
            printf("err: %d", GetLastError());  
            return 1;  
        }  
     
        lpfnDllFunc = (LPFNDLLFUNC)GetProcAddress(hInst, "GetMin");  
     
        if (lpfnDllFunc == NULL)  
        {  
            printf("err: %d", GetLastError());  
            FreeLibrary(hInst);  
            return 1;  
        }  
     
        //调用GetMin  
        c = lpfnDllFunc(a, b);  
        FreeLibrary(hInst);  
    #endif  
     
        printf("GetMin( %d, %d): %d",a, b, c);  
        return 0;  

     

          通过示例我们可以看出,静态链接库的使用方法和隐式链接十分相似,它们都用到了.lib文件.这里一下说明他们.lib文件的区别:
    静态库.lib它包含了变量和函数的实现。作为动态链接库的.lib不包含任何函数和变量,它只是列出所有已输出的函数和变量的符号名.

          动态链接库和静态链接库的区别:
    静态链接库在编译期把所有的代码和数据都生成到执行程序,运行时就不再需要库了。
    动态链接库在编译期只建立一个引用的接口,而真正的代码和数据存放在另外的可执行模块中,在运行时再装入.

          隐式链接和显式链接的区别:
    隐式链接:程序在启动时就加载DLL模块.直到程序结束时才卸载DLL模块.在此期间可以直接调用Dll的函数等.
    显式链接:在调用LoadLibrary()时才加载DLL模块,要使用函数通过GetProcessAddress()来得函数址址.调用FreeLibrary()就可以释放DLL资源.

     

     

     

     

     

    展开全文
  • C/C++的动态库和静态库 CC的动态库和静态库 静态库 静态库特点 生成静态库 静态库的两大缺点 动态库 动态库特点 生成动态库 使用动态库 在Linux下显式调用动态库 注意显式调用C动态库 静态库动态库的使用 ...

    C/C++的动态库和静态库

    静态库

    在链接阶段,将汇编生成的目标文件.o与引用到的库一起链接打包到可执行文件(.a)就是静态库。

    静态库特点

    • 静态库对函数库的链接是放在编译时期完成的。
    • 程序在运行时与函数库再无瓜葛,移植方便。
    • 浪费空间和资源,因为所有相关的目标文件与牵涉到的函数库被链接合成一个可执行文件。

    生成静态库

    假设有三个源文件helloworld_1.c helloworld_2.c helloworld.h

    $ gcc -c helloworld_1.c helloworld_2.c #生成helloworld_1.o helloworld_2.o
    $ ar crv libhelloworld.a helloworld_1.o helloworld_2.o

    ar 命令用来生成静态库 ,crv 是命令选项:
    - c 如果需要生成新的库文件,不要警告
    - r 代替库中现有的文件或者插入新的文件,一般必选
    - v 输出详细信息

    注意:生成的库名必须遵守规范,lib[static_library_name].a:lib为前缀,中间是静态库名,扩展名为.a。
    此外,静态库提供者同时应该提供头文件,使用该静态库的程序,必须包含头文件。

    静态库的两大缺点:

    • 空间浪费:静态库参与形成的每个可执行程序将静态库拷贝,并加载进内存,即每个用到该静态库的进程会单独拥有一份该静态库的拷贝。同时,静态库生成的时候,会将其调用的所有的库打包在一起,而动态库却是只将自身的代码生成库文件。因此,相同代码生成的静态库本来就比动态库大,再加上调用时被拷贝多份,自然会浪费很多内存空间。
    • 另一个问题是静态库对程序的更新、部署和发布页会带来麻烦。如果静态库libhelloworld.a更新了,所以使用它的应用程序都需要重新编译、发布给用户(对于玩家来说,可能是一个很小的改动,却导致整个程序重新下载,全量更新)。

    动态库

    动态库在程序编译时并不会被连接到目标代码中,而是在程序运行是才被载入。不同的应用程序如果调用相同的库,那么在内存里只需要有一份该共享库的实例,规避了空间浪费问题。
    动态库在程序运行是才被载入,也解决了静态库对程序的更新、部署和发布页会带来麻烦。用户只需要更新动态库即可,增量更新。

    动态库特点

    • 动态库把对一些库函数的链接载入推迟到程序运行的时期。
    • 可以实现进程之间的资源共享。(因此动态库也称为共享库)
    • 将一些程序升级变得简单。
    • 甚至可以真正做到链接载入完全由程序员在程序代码中控制(显式调用)。

    生成动态库

    假设有三个源文件helloworld_1.c helloworld_2.c helloworld.h
    以下代码可以生成libhelloworld.so

    $ gcc -fPIC -c helloworld_1.c helloworld_2.c #生成helloworld_1.o helloworld_2.o
    $ gcc -shared -o libhelloworld.so helloworld_1.o helloworld_2.o

    或者:
    gcc -fPIC -shared -o libhelloworld.so helloworld_1.c helloworld_2.c

    使用动态库

    动态库当然可以像静态库一样,包含头文件,然后使用它,但是它还有一些其他的调用方式

    在Linux下显式调用动态库

    #include <dlfcn.h>,提供了下面几个接口:
    - void * dlopen( const char * pathname, int mode ):函数以指定模式打开指定的动态连接库文件,并返回一个句柄给调用进程。
    - void* dlsym(void* handle,const char* symbol):dlsym根据动态链接库操作句柄(pHandle)与符号(symbol),返回符号对应的地址。使用这个函数不但可以获取函数地址,也可以获取变量地址。
    - int dlclose (void *handle):dlclose用于关闭指定句柄的动态链接库,只有当此动态链接库的使用计数为0时,才会真正被系统卸载。
    - const char *dlerror(void):当动态链接库操作函数执行失败时,dlerror可以返回出错信息,返回值为NULL时表示操作函数执行成功。

    注意:显式调用C++动态库

    因为c++c的符合命名的规则差异,显式调用C++动态库的时候,动态库中的接口最好都用extern "C"声明。注意:只有非成员函数才能被声明为extern “C”,并且不能被重载。冠以extern “C”限定符后,并不意味着函数中无法使用C++代码了,相反,它仍然是一个完全的C++函数,可以使用任何C++特性和各种类型的参数。
    在C++中,您可能要用到库中的一个类,而这需要创建该类的一个实例,这很难用显式调用做到。
    最后,”显式”使用C++动态库中的Class是非常繁琐和危险的事情,因此能用”隐式”就不要用”显式”,能静态就不要用动态。

    静态库动态库的使用

    注意事项:

    • 应用程序需要连接外部库的情况下,linux默认对库的连接是使用动态库(.so),在找不到动态库的情况下再选择静态库(.a)。
      因此,当链接目录下同时存在libtest.solibtest.a的时候,使用-ltest会链接libtest.so
      如果要想链接静态库有以下方法:
      1、将静态库改名为libstatictest.a,使用-lstatictest选项。或者将动态库改名。
      2、使用-static选择,但是:当对动态库与静态库混合连接的时候,使用-static会导致所有的库都使用静态连接的方式。
      3、使用-Wl,-Wl,-Bstatic后面的-lxxxx系统会查找静态库;-Wl,-Bdynamic后面的-lxxxx,系统会查找动态库。

    • 动态库使用时必须指定绝对链接路径,或者将静态库拷贝到默认的动态库搜索路径下,或者将动态库所在目录加到$LD_LIBRARY_PATH内。或者在/etc/ld.so.conf 中添加指定的链接库搜索路径(需要root权限),注:需要运行 /sbin/ldconfig,以达到刷新 /etc/ld.so.cache的效果。

    • 静态库可以使用相对路径,或者直接在编译选择后面加上文件位置而不使用-l例:g++ -o main main.cpp ../libhelloworld.a

    动态库和静态库的不同

    链接库 静态库 static 动态库 dynamic
    本质 可执行文件的集合 符号集
    加载时间 编译时静态加载 运行时动态加载
    头文件 必须包含 显式调用不需要包含头文件
    空间大小 大,包含所有调用到的库 小,只包含自己的代码库
    共享 否,将静态库编译进了可执行文件,进程独占 共享库,每个进程都调用一个位置的库
    移植性 强,包含完整运行所需要的库环境 差,库里代码执行还要依赖系统的库
    迭代性 差,静态库改变所有使用该库的程序都需要重新链接 好,甚至支持热更新
    链接路径 可以使相对路径 不可以使用相对路径
    链接优先级 同路径同名会优先链接动态库 同路径同名会优先链接动态库
    环境变量 $LIBRARY_PATH $LD_LIBRARY_PATH

    静态库链接: 静态库的代码在编译过程中已经被载入可执行程序,因此体积较大。 优点就显而易见了,即编译后的执行程序不需要外部的函数库支持,可移植性好,因为所有使用的函数都已经被编译进去了。当然这也会成为他的缺点,因为如果静态函数库改变了,那么你的程序必须重新编译。

    (动态库)共享库的代码是在可执行程序运行时才载入内存的,在编译过程中仅简单的引用,因此代码体积较小。 由于函数库没有被整合进你的程序,而是程序运行时动态的申请并调用,所以程序的运行环境中必须提供相应的库。动态函数库的改变并不影响你的程序,所以动态函数库的升级比较方便

    静态库的好处:
    1、模块化,分工合作
    2、避免少量改动经常导致大量的重复编译连接
    3、也可以重用,注意不是共享使用
    4、跨平台性好

    动态库使用有如下好处:
    1、使用动态库,可以将最终可执行文件体积缩小
    2、使用动态库,多个应用程序共享内存中得同一份库文件,节省资源
    3、使用动态库,可以不重新编译连接可执行程序的前提下,更新动态库文件达到更新应用程序的目的。

    静态库动态库链接搜索路径

    静态库链接时搜索路径顺序:
    1. ld会去找GCC命令中的参数-L
    2. 再找gcc的环境变量LIBRARY_PATH
    3. 再找内定目录 /lib /usr/lib /usr/local/lib 这是当初compile gcc时写在程序内的

    动态链接时、执行时搜索路径顺序:
    1. 编译目标代码时指定的动态库搜索路径
    2. 环境变量LD_LIBRARY_PATH指定的动态库搜索路径
    3. 配置文件/etc/ld.so.conf中指定的动态库搜索路径
    4. 默认的动态库搜索路径/lib
    5. 默认的动态库搜索路径/usr/lib

    If you ever happen to want to link against installed libraries
    in a given directory, LIBDIR, you must either use libtool, and
    specify the full pathname of the library, or use the `-LLIBDIR'
    flag during linking and do at least one of the following:
       - add LIBDIR to the `LD_LIBRARY_PATH' environment variable
         during execution
       - add LIBDIR to the `LD_RUN_PATH' environment variable
         during linking
       - use the `-Wl,-rpath -Wl,LIBDIR' linker flag
       - have your system administrator add LIBDIR to `/etc/ld.so.conf'

    头文件相关

    使用各种外部库,免不了会出现编译时找不到头文件的情况:

    除默认的/usr/include, /usr/local/include等include路径外,
    还可以通过设置环境变量来添加系统include的路径:

    #C
    export C_INCLUDE_PATH=XXXX:$C_INCLUDE_PATH
    #CPP
    export CPLUS_INCLUDE_PATH=XXX:$CPLUS_INCLUDE_PATH

    还可以编译时通过 -I选项来执行头文件目录。
    注意:gcc不会搜索c++的头文件,所以编译c++文件的时候,记得用g++

    其他:

    无论是使用动态库还是外部库链接时都是使用的ld连接器;
    使用动态库的程序执行时使用动态加载器。在Linux 下,加载器是/lib/ld-Linux.so.X(X是版本号)。然后加载器搜索、加载程序所要使用的动态链接库。
    - 使用ldd可以看到依赖的库

    展开全文
  • 动态库和静态库 介绍 静态库和动态库的区别 举个例子, iOS 项目中使用 Embeded Framework 静态库和动态库如何构建和加载 静态库和动态库依赖关系 Xcode 项目结构 iOS ...
  • 本视频课程介绍C语言中动态库和静态库的基本概念,制作和使用方法,手工加载动态库方法,如何导出函数和类,以及VC的静态编译等等
  • QT 动态库和静态库的实现和调用

    千次阅读 2018-05-23 12:34:55
    QT 动态库和静态库的实现和调用一、简述 加强某一部分代码的保密性,将其打包成动态库或静态库;或者是调用其他开源的库文件。二、效果三、工程结构四、源文件...
  • Android 动态库和静态库的编译与区别

    千次阅读 2020-01-15 15:09:52
    Android 动态库和静态库的编译与区别 函数库分为静态库和动态库两种。 静态库在程序编译时会被连接到目标代码中,程序运行时将不再需要该静态库。 Android.mk 编译成静态库:include $(BUILD_SHARED_LIBRARY) 使用该...
  • 一、库的基础概念: 在windows平台和linux平台下都大量存在着库。本质上来说库是一种可执行代码的二进制形式,可以被操作系统载入内存执行。...按照库的使用方式又可分为动态库和静态库,在不同平台下...
  • iOS里的动态库和静态库

    千次阅读 2018-10-11 09:08:32
    动态库和静态库的区别 静态库:链接时,静态库会被完整地复制到可执行文件中,被多次使用就有多份冗余拷贝(图1所示) 系统动态库:链接时不复制,程序运行时由系统动态加载到内存,供程序调用,系统只加载一次...
  • linux编译动态库和静态库的makefile示例
  • Linux C 编程入门之一:gcc 编译动态库和静态库 cheungmine 2012 1 准备工作 Windows7+Cygwin+gcc 在同一个目录下准备好下面3个文件,其中3-2,3-3用来生成动态库或静态库:
  • 本文介绍使用cmake来编译动态库和静态库,源码非常简单,重点是掌握文件的组织方式以及cmake的使用。 文章目录目录结构add.cCMakeLists.txtCMAKE_ARCHIVE_OUTPUT_DIRECTORYCMAKE_LIBRARY_OUTPUT_DIRECTORYadd_...
  • C语言多线程,动态库和静态库

    千次阅读 2016-06-11 10:52:38
    C语言多线程,动态库和静态库
  • Android NDK种的动态库和静态库就是linux下的动态库和静态库,因为NDK的开发可以理解从基于Linux的开发。 在平时工作中我们经常把一些常用的函数或者功能封装为一个个库供给别人使用,java开发我们可以封装为jar包...
  • 文章目录cmake模板—生成自己的动态库和静态库目录结构顶层CMakeLists.txtsrc里的CMakeLists.txtlib里的CMakeLists.txt cmake模板—生成自己的动态库和静态库 目录结构 进入build,执行cmake …;make;make install...
  • linux下有两种库:动态库和静态库(共享库)二者的不同点在于代码被载入的时刻不同。静态库的代码在编译过程中已经被载入可执行程序,因此体积比较大。动态库(共享库)的代码在可执行程序运行时才载入内存,在编译过程中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,737
精华内容 5,494
关键字:

动态库和静态库