精华内容
下载资源
问答
  • 静态库 后缀 .a 每次被调用都生成一个副本 共享库(动态库) 后缀.so 只有一个副本 windows 静态库 后缀 .lib 动态库 后缀.dll 静态库的生成和使用 通常情况下,对函数库的链接是放在编译时期...

    linux

    Linux下的库必须以lib开头,用于系统识别

    静态库 后缀 .a  每次被调用都生成一个副本


    共享库(动态库) 后缀.so  只有一个副本


    windows

    静态库 后缀 .lib

    动态库 后缀.dll


    静态库的生成和使用


    通常情况下,对函数库的链接是放在编译时期(compile time)完成的。所有相关的对象文件(object file)与牵涉到的函数库(library)被链接合成一个可执行文件(executable file)。程序在运行时,与函数库再无瓜葛,因为所有需要的函数已拷贝到自己门下。所以这些函数库被成为静态库(static libaray),通常文件名为“libxxx.a”的形式。


    静态库必要的目标代码的是在对程序编译的时候被加入到程序中,而运行时不再需要.a的库了


    生成静态库:

    gcc -c try1.c  
    gcc -c try2.c
    ar cqs libtry.a try1.o try2.o(或 ar r libtry.a try1.o try2.o)

    使用:

    gcc -c main.c -o main.o  
    gcc main.o -o name -L. -ltry (-l后面的名字就是我们上面生成的try库) 

    动态库的生成和使用


    动态链接库的特点与优势

    首先让我们来看一下,把库函数推迟到程序运行时期载入的好处:

    1. 可以实现进程之间的资源共享。

    什么概念呢?就是说,某个程序的在运行中要调用某个动态链接库函数的时候,操作系统首先会查看所有正在运行的程序,看在内存里是否已有此库函数的拷贝了。如果有,则让其共享那一个拷贝;只有没有才链接载入。这样的模式虽然会带来一些“动态链接”额外的开销,却大大的节省了系统的内存资源。C的标准库就是动态链接库,也就是说系统中所有运行的程序共享着同一个C标准库的代码段。

    2. 将一些程序升级变得简单。用户只需要升级动态链接库,而无需重新编译链接其他原有的代码就可以完成整个程序的升级。Windows 就是一个很好的例子。

    3. 甚至可以真正坐到链接载入完全由程序员在程序代码中控制。

    程序员在编写程序的时候,可以明确的指明什么时候或者什么情况下,链接载入哪个动态链接库函数。你可以有一个相当大的软件,但每次运行的时候,由于不同的操作需求,只有一小部分程序被载入内存。所有的函数本着“有需求才调入”的原则,于是大大节省了系统资源。比如现在的软件通常都能打开若干种不同类型的文件,这些读写操作通常都用动态链接库来实现。在一次运行当中,一般只有一种类型的文件将会被打开。所以直到程序知道文件的类型以后再载入相应的读写函数,而不是一开始就将所有的读写函数都载入,然后才发觉在整个程序中根本没有用到它们。



    把一个源代码编译成.so


    gcc -shared -o libtry.so try.c  




    1.显式调用

    不推荐


    2.隐式调用

    所谓隐式调用,就是调用的时候直接使用动态库中的函数,并不区别对待。

    但是在隐式调用的时候必须要让程序能找到你所调用的函数的所属动态库。

    我们先来建立一个感性认识:    

    # more /etc/ld.so.conf 你会看到以下内容:   


    /usr/kerberos/lib    

    /usr/X11R6/lib    

    /usr/lib/sane    

    /usr/lib/qt-3.1/lib    

    /usr/lib/mysql    

    /usr/lib/qt2/lib    

    /usr/local/lib    

    /usr/local/BerkeleyDB.4.3/lib

     

    ld.so.conf是系统对动态链接库进行查找的路径配置文件,也就是说该文件是系统链接工具/usr/bin/ld查找动态链接库的地图,所以,要达到我们的目的有以下几种方法:

    a.将自己的动态链接库文件拷到以上路径的目录下

        # cp libwx.so.1 /usr/local/lib

    b.将自己动态链接库文件的路径加入到该文件中

        # vi /etc/ld.so.conf然后加入自己的路径(pwd >>/etc/ld.so.conf)

        (千万不要将>>写成>,前者是添加,后者是覆盖)

    c.把当前路径加入环境变量LD_LIBRARY_PATH,其实就是/usr/bin/ld的环境变量

        # export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH

        

    编译的时候:    

    # gcc -o try main.c libtry.so.1    

    如果没有让/usr/bin/ld知道你的动态链接库在哪,编译的时候就要告诉它:    

    # gcc -o try main.c /root/libtry.so.1 ( 或:# gcc -L/root/wx -o qqq main.c libmy.so.1)

    -L指定动态链接库所在的目录,有时候用gcc还会碰到-I-l,他们分别指定头文件的目录和所链接的动态链接库

     

     

    # ldd try    用来查看可执行文件qqq的动态链接库的依赖关系

            libjpeg.so.62 => /usr/lib/libjpeg.so.62 (0x00867000)

            libSDL-1.2.so.0 => /usr/lib/libSDL-1.2.so.0 (0x0638a000)

            libc.so.6 => /lib/tls/libc.so.6 (0x0046d000)

            libm.so.6 => /lib/tls/libm.so.6 (0x00598000)

            libdl.so.2 => /lib/libdl.so.2 (0x005bd000)

            libasound.so.2 => /lib/libasound.so.2 (0x062e1000)

            libX11.so.6 => /usr/X11R6/lib/libX11.so.6 (0x005d5000)

            libXext.so.6 => /usr/X11R6/lib/libXext.so.6 (0x0069e000)

            libpthread.so.0 => /lib/tls/libpthread.so.0 (0x006ae000)

            /lib/ld-linux.so.2 (0x00450000)






    展开全文
  • windows中封装静态库例程

    千次阅读 2016-09-05 22:28:19
    windows平台下编写程序时,常常会希望别人能够使用自己的代码,但是又不希望别人看见你的代码,那么有... windows下的静态库后缀名为lib。我们通过将源文件打包成为lib文件,然后同时给别的开发者提供一个说明接

      在windows平台下编写程序时,常常会希望别人能够使用自己的代码,但是又不希望别人看见你的代码,那么有没有什么方法可以解决这个问题呢?

      当然有,在windows平台下,通过将源文件打包成为静态库或者动态库,就可以完美的解决这个问题。本文通过例子的形式讲解静态库的生成过程。

      windows下的静态库的后缀名为lib。我们通过将源文件打包成为lib文件,然后同时给别的开发者提供一个说明接口的头文件,这样别人就可以使用你的静态库了。

      首先,我们新建4个文件,作用如下

      a.c:主函数所在的文件

      b.c功能函数实现的文件 被a.c中的主函数调用

      b.h功能函数实现文件的头文件

      makefile:makefile 源文件


      所有文件的具体内容如下:

      a.c

    #include"stdio.h"
    #include"b.h"
    
    void main(void)
    {
    	int i;
    	i = multiple(3,4);
    	printf("hello makefile\n");
    	printf("i = %d\n",i);
    }


    b.c

    #include"b.h"
    
    int multiple(int a, int b)
    {
    	return a * b;
    }


    b.h

    #ifndef B_H
    #define B_H
    
    int multiple(int a, int b);
    
    #endif


    makefile

    TOOLDIR = D:\MyDownloads\Download\VC6.0green\VC98
    DIR = $(TOOLDIR)\Include
    LIB_DIR = $(TOOLDIR)\Lib
    
    INCDIR = -I b.h -I $(DIR)
    LIB = $(LIB_DIR)/LIBC.LIB $(LIB_DIR)/OLDNAMES.LIB \
    $(LIB_DIR)/KERNEL32.LIB
    
    
    Test:a.obj b.lib
    	-Link a.obj b.lib $(LIB)
    
    a.obj:a.c
    	-cl a.c $(INCDIR) $(LIB)
    
    b.lib:b.obj
    	-lib b.obj
    
    b.obj:b.c
    	-cl b.c $(INCDIR) $(LIB)
    
    .PHONY:clean
    clean:
    	@echo clean the following files:
    	-rm *.exe
    	-rm *.obj
    	-rm *.lib
    	@echo Done!

    makefile的作用就是现将a.c编译成为a.obj。然后将b.c编译成为b.lib,最后将这两个链接成为目标文件

      

      在运行makefile后会生成一个b.lib文件,这样以来,你就可以将你工程目录中的b.c去掉了,在需要时,你将b.c和b.lib给别人就行了。

    展开全文
  • windows静态库是以 .lib 为后缀的文件,动态库是以 .dll 为后缀的文件。在linux中静态库是以 .a 为后缀的文件,共享库是以 .so为后缀的文件。 当程序与静态库连接时,库中目标文件所含的所有将被程序使用的函数...

    方法库大体上可以分为两类:静态库和动态库(共享库)。

    1. windows中静态库是以 .lib 为后缀的文件,动态库是以 .dll 为后缀的文件。

    2. linux中静态库是以 .a 为后缀的文件,动态库是以 .so为后缀的文件。

    3. mac中静态库是以.a为后缀的文件,动态库是以.dylib为后缀的文件,以.framework为后缀的文件可能是静态库,也可能是动态库。


           当程序与静态库链接时,静态库中所包含的所有函数方法都会被copy到最终的可执行文件中去。这就会导致最终生成的可执行代码量相对变多,相当于编译器将代码补充完整了。这种方式会让程序运行起来相对快一些,不过也会有个缺点: 占用磁盘和内存空间,导致可执行exe程序过大。另外,静态库会被添加到和它链接的每个程序中去, 而且这些程序运行时, 都会被加载到内存中,无形中又多消耗了更多的内存空间。


           与动态库链接的可执行文件只包含它需要的函数方法的引用表,而不是所有的函数代码,只有在程序执行时, 那些需要的函数代码才会被拷贝到内存中。这样就使可执行文件比较小, 节省磁盘空间,更进一步,操作系统使用虚拟内存,使得一份动态库驻留在内存中被多个程序使用,也同时节约了内存。不过由于运行时要去链接库会花费一定的时间,执行速度相对会慢一些。

           总的来说,静态库是牺牲了空间效率,换取了时间效率,动态库是牺牲了时间效率换取了空间效率,没有好与坏的区别,只看具体需要了。


           另外,一个程序编好后,有时需要做一些修改和优化,如果我们要修改的刚好是库函数的话,在接口不变的前提下,使用动态库的程序只需要将动态库重新编译就可以了,而使用静态库的程序则需要将静态库重新编译好后,将程序再重新编译一遍。
           

           上述内容大致是动态库与静态库的明显区别。

     

    参考链接:http://blog.csdn.net/sunshinewave/article/details/39155755

    展开全文
  • 静态库: 源代码被链接到调用的程序或动态库,被调用时,代码最少有1份,文件后缀.LIB 动态库: 函数被程序或其他动态库调用,被调用时,代码只有1份,文件后缀.DLL 静态库(C语言): 创建时,选择文本类型文件,输入Clib.c...
    windows库程序:

    静态库:

    源代码被链接到调用的程序或动态库,被调用时,代码最少有1份,文件后缀.LIB

    动态库: 函数被程序或其他动态库调用,被调用时,代码只有1份,文件后缀.DLL


    静态库(C语言):
    创建时,选择文本类型文件,输入Clib.c,设置输出路径 ../lib/Clib.lib


    int Clib_add(int a,int b)
    {
    return a+b;
    }
    同一上工作区,建立控制台程序(.c文件)调用静态库:
    #include<STDIO.H>
    #pragma comment(lib,"../lib/Clib.lib") //包含静态库文件
    //可以在 工程-设置-连接-对象/库模块 中加入静态库相对地址 ../lib/Clib.lib
    int main()
    {
    int sum=Clib_add(12,34);
    printf("12+34 结果是:%d\n",sum);
    return 0;
    }


    C++程序调用C++静态库,与C中大部分一样,但调用之前,要写函数声明。

    C++程序调用C静态库,写函数声明时,前面加 extern "C".

    使用静态库示例:

    新建 win32 static library工程(Clib):

    新建一个文件,Clib.c,代码:

    int Clib_add(int a,int b)
    {
    	return a+b;
    }
    int Clib_sub(int a,int b)
    {
    	return a-b;
    }

    生成,产生一个 Clib.lib文件。

    新建C控制台程序,使用静态库,代码:

    #include<STDIO.H>
    #pragma comment(lib,"../lib/Clib.lib") //包含静态库文件
    //可以在 工程-设置-连接-对象/库模块 中加入静态库相对地址 ../lib/Clib.lib
    int main()
    {
    	int sum=Clib_add(12,34);
    	printf("12+34 结果是:%d\n",sum);
    	return 0;
    }
    


    动态库:

    (项目:Cdll):
    在函数前加 _declspec(dllexport),声明方式导出动态库函数地址到.lib。
    生成的.dll和.lib(.lib要手动复制到lib文件夹)。


    C程序调用:
    #pragma comment(lib,"../lib/Cdll.lib")//函数地址文件
    //在运行时,Cdll.dll文件要放在与程序同一目录中或系统PATH目录中
    //(隐式链接动态库dll)




    C++程序调用C++动态库,与C中大部分一样,但调用之前,要写函数声明。
    C++程序调用C动态库,写函数声明时,前面加 extern "C".


    显式链接dll的方法(不使用lib文件,要建立.def文件):
    1.定义函数指针类型
    2.加载动态库
    3.获取函数地址
    4.使用函数
    5.卸载动态库
    .def文件格式:
    LIBRARY CPPdll
    EXPORTS
      CPPdll_add @1
      CPPdll_sub @2
      CPPdll_multi @3
    示例:

    新建动态库Cdll项目,win32 Dynamic-link library

    新建一个Cdll.c文件,内容:

    _declspec(dllexport) int Cdll_add(int a,int b)
    {
    	return a+b;
    }
    

    新建一个c控制台程序,使用动态库,内容:

    #include <STDIO.H>
    #pragma comment(lib,"../lib/Cdll.lib")//函数地址文件
    //.dll文件要放在与程序同一目录中
    int main()
    {
    	int sum=Cdll_add(34,56);
    	printf("34+56=%d\n",sum);
    	return 0;
    }
    


    C++中使用示例:

    //CPPdll项目中:

    //CPPdll.cpp

    _declspec(dllexport) int CPPdll_add(int a,int b)
    {
    	return a+b;
    }

    //CPPdll.def

    LIBRARY CPPdll
    EXPORTS
      CPPdll_add @1
    

    编译生成dll和lib,

    新建测试项目调用CPPdll和Cdll

    #include<STDIO.H>
    #pragma comment(lib,"../lib/CPPdll.lib")//C++调用c++的动态库
    #pragma comment(lib,"../lib/Cdll.lib")//c++调用c的动态库
    extern "C" _declspec(dllexport)  int Cdll_add(int a,int b);
    _declspec(dllexport) int CPPdll_add(int a,int b);
    int main()
    {
    	int sum=CPPdll_add(23,45);
    	printf("23+45=%d\n",sum);
     	int sum2=Cdll_add(231,45);
     	printf("231+45=%d\n",sum2);
    	return 0;
    }
    

    附:显示调用CPPdll

    #include <STDIO.H>
    #include <WINDOWS.H>
    //动态库加.def 文件申明函数地址
    typedef int(*DLL_ADD)(int a,int b);//函数类型
    int main()
    {
    HINSTANCE dll= LoadLibrary("CPPdll.dll");//加载动态库
    DLL_ADD add=(DLL_ADD)GetProcAddress(dll,"CPPdll_add");
    int sum=add(23,45);
    printf("23+45=%d\n",sum);
    FreeLibrary(dll);
    return 0;
    }



    动态库中的类定义:
    //dllclass.h文件,可以公开给调用方
    #ifndef DLLCLASS_H
    #define DLLCLASS_H
    #ifdef DLLCLASS_EXPORTS     //在动态库.cpp中要定义,来表示导出
    #define EXT_CLASS _declspec(dllexport) //cpp文件使用,导出
    #else
    #define EXT_CLASS _declspec(dllimport) //别人调用,导入
    #endif
    class EXT_CLASS CMath
    {
    public:
    int add(int a,int b);
    };
    #endif


    //dllclass.cpp文件
    #define DLLCLASS_EXPORTS
    #include <WINDOWS.H>
    #include <STDIO.H>
    #include "dllclass.h"
    //动态库入口函数,返回false则表示调用不成功
    BOOL CALLBACK DllMain(HANDLE hDllHandle, DWORD dwReason, LPVOID lpReserved)
    {
    switch(dwReason)
    {
    case DLL_PROCESS_ATTACH://进程加载,初始化
    {
    printf("loading dll ……\n");
    }
    break;
    case DLL_PROCESS_DETACH://进程卸载,清理资源
    {
    printf("unloading dll ……\n");
    }
    break;
    }
    return true;
    }
    int CMath::add(int a,int b)
    {
    return a+b;
    }


    //调用
    #include "../dllclass/dllclass.h"//包含类声明文件
    #pragma comment(lib,"../lib/dllclass.lib") //包含静态库文件

    int main()

    {
    CMath math;
    int sum3=math.add(3,4);
    cout<<"3+4 结果是:"<<sum3<<endl;

    return 0;

    }




    展开全文
  • 库是一种软件组件技术,库里面封装了数据和函数。库的使用可以使程序模块化。Windows系统包括静态链接库(.lib文件)和动态链接库(.dll文件)。Linux通常把库文件存放在/usr/lib或/lib目录下。...静态库的代码...
  • 动态库和静态库

    2019-07-16 14:20:19
    title: 动态库和静态库 date: 2019-06-16 17:38:12 tags: - Linux categories: - Linux 动态链接库、静态链接库。...Windows 下,以 lib 开头,.lib是静态库,.dll是动态库。 静态库 Windows 下 的后缀是 .lib,Linu...
  • Windows下用DEV C++建立静态库和动态库

    千次阅读 2018-06-07 12:52:08
    (2018.6.6)一、新建项目: 二、在里面加入你的函数:(编译) 三、编译后到工程目录下查看是否产生了后缀位.a的文件(与你的项目名是一致的) 四、使用这个静态链接:1.首先新建一个.h文件到你的项目里面,...
  • 动态库与静态库

    2019-03-17 20:14:18
    1.在windows静态库是以.lib为后缀的文件,共享库是以.dll为后缀的文件。在linux中静态库是以.a为后缀的文件,共享库是以.so为后缀的文件。 2.以linux下的静态库和动态库为例我们研究一下,首先我们看一下他们的...
  • 一般分为动态库和静态库,在Windows操作系统中静态库是以 .lib 为后缀的文件,动态库是以 .dll 为后缀的文件。 C++程序编译以及调用库的过程如下: 可以看到库是在链接过程和目标文件一起打包最终生成可执行文件,...
  • 库是一种软件组件技术,库里面封装了数据和函数。库的使用可以使程序模块化。Windows系统包括静态链接库(.lib文件)和动态链接库(.dll文件)。Linux通常把库文件存放在/usr/lib或/lib目录下。...静态库的代码...
  • 发现非技术的小伙伴经常被一些技术名词困扰,今天说一下静态库和动态库。以下都以 Windows 系统上的文件后缀和格式为例,各系统原理上都是一样的。全称其实是静态链接库和动态链接库,一个最简单的程序产生过程是...
  • 1.什么是库 在windows平台和linux平台下都大量存在着库。本质上来说库是一种可执行代码的二进制形式,... linux下的库有两种:静态库和共享库(动态库)。动态通常用.so为后缀,静态用.a为后缀。例如:libhello...
  • 标准windows静态库,只有头文件和.lib,没有DLL。 VS工程属性如下: A.lib中想调用另一个B.lib,如果B放在A中链接,会出现报错,无法链接上或者无法识别等各种奇怪错误。 正确方式 在exe中导入lib的链接,也...
  • 静态库与动态库

    2018-04-15 10:21:30
    1.什么是库: ...在windows静态库是以 .lib 为后缀的文件,共享库是以 .dll 为后缀的文件。在linux中静态库是以 .a 为后缀的文件,共享库是以 .so为后缀的文件。 2.案例:main.c文件中调用了a
  • GCC静态库和动态库

    2019-05-29 21:42:43
    什么是库: 个人理解就是把这些常用函数的目标文件打包在一起,提供相应函数的接口,便于程序员...在windows中,静态库是以.lib为后缀的未见,共享库是以.dll为后缀的文件。 **静态库:**静态库在程序编译时会被连接...
  • 关于动态库和静态库

    2017-12-01 10:39:18
    1: 在windows静态库是以 .lib 为后缀的文件,共享库是以 .dll 为后缀的文件。在linux中静态库是以 .a 为后缀的文件,共享库是以 .so为后缀的文件。 2 : 库即为源代码的二进制文件(本质上来说库是...
  • windows文件的后缀xxx.dlllinux下的文件的后缀xxx.a xxx.solinux可以用命令ar 来创建ar的命令参数:c:如果目标文件不存在 则默认的就创建该r:把目标文件包含在中 替换任何已经在档案中存在的同名的目标...
  • windows平台和linux平台下都大量存在着。一般是软件作者为了发布方便、替换方便或二次开发目的,而发布的一组可以单独与应用程序进行compile time或runtime链接的二进制可重定位目标码文件。本质上来说是一种...
  • Linux 静态库简析

    2021-01-22 23:49:44
    程序函数库又分为:静态库、动态库、共享函数库,实际上后两者是一个东西。在windows上叫动态加载函数库,文件后缀是.dll;在Linux中则叫共享对象库, 文件后缀是.so。 Linux中命名系统中共享库的规则: 静态库的...
  • 动态库、静态库 介绍  在Windows平台和linux平台存在着大量的库。本质上说库是一种可执行的二进制代码,可以被操作系统直接载入内存。 linux下的库有两种:静态库和共享库(动态库)。... 静态库后缀
  • 静态库Windows中为后缀为.lib的文件,Linux中为.a文件; 动态库:Windows中为后缀为.dll的文件,Linux中为.so文件; Windows中: 调用静态库:将静态库路径添加进来——依赖静态库(或者#pragma comment(lib...
  • 先说明一点,静态库文件是由多个目标文件打包而成的,在windows静态库文件的后缀是.lib,而在linux下静态库文件的后缀是.a(a是archive的缩写,也就是文档文件)。废话少说,下面直接进入主题。1.创建两个c文件:...
  • 静态库和动态库

    2015-08-11 09:57:00
    静态库进行编译和链接的时间。库文件来运行所有的代码文件,因此,生成的文件都很大,运行时库文件也不需要。Linux扩展静态库一般是”.a”。windows为”.Lib”。 态函数库是在编译链接时没有把库文件代码增加到可...
  • 静态库和动态库小结

    2015-07-20 18:11:55
    2) 静态库程序 文件后缀为.lib 的文件 3)动态库程序 文件后缀名为.dll的文件控制台程序和动态库程序都有入口函数,静态库程序没有入口函数。静态库程序一直存在于硬盘上,不会进入到内存中,当程序运行时会被 链接...
  • Windows静态库的后缀为:.lib、动态库后缀为:.dll;而在Linux下静态库的后缀为:.a、动态库的后缀为:.so。 那么什么是静态库呢? 首先我们来看看程序编译的大体流程:预处理——编译——汇编——链接 在...
  • 我们在编写代码的时候经常用到已有的接口,他们是以库的形式提供给我们使用的,而常见形式有两种,一种常以.a为后缀,为静态库;另一种以.so为后缀,为动态库。那么这两种库有什么区别呢? 说明:本文主要说明Linux...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 364
精华内容 145
关键字:

windows静态库后缀