源代码lib静态库adll动态库
静态库和动态库编译
静态库和动态库编译静态库和动态库是编程中常用的两种库文件形式，本文将介绍它们的编译过程和使用方法。
1. 静态库编译静态库是一种在编译时被链接到程序中的库文件，它包含了程序所依赖的所有函数和数据结构，因此程序在运行时不需要再加载库文件。
静态库的编译过程包括以下步骤：（1）创建一个或多个源文件，使用编译器将它们编译成目标文件（.o 或 .obj）。
（2）将多个目标文件打包成一个静态库文件，通常使用 ar 工具完成此操作。
例如，在 Linux 系统下，可以使用以下命令创建名为 libfoo.a 的静态库文件：$ ar rcs libfoo.a foo1.o foo2.o ...其中，rcs 参数分别表示创建、向库文件中添加目标文件和生成索引表。
（3）在编译器中使用静态库，需要将其链接到目标程序中。
在Linux 系统下，可以使用以下命令编译名为 main.c 的源文件和名为libfoo.a 的静态库文件：$ gcc -o main main.c -L. -lfoo其中，-L 参数指定库文件搜索路径，. 表示当前目录；-l 参数指定链接库文件，实际上是将其前缀 lib 和后缀 .a 去掉，即 foo。
2. 动态库编译动态库是一种在程序运行时动态加载的库文件，它只包含程序所需要的部分函数和数据结构，因此可以减小程序的尺寸和加载时间。
动态库的编译过程包括以下步骤：（1）创建一个或多个源文件，使用编译器将它们编译成目标文件。
（2）将多个目标文件打包成一个共享库文件，通常使用 ld 或链接器完成此操作。
例如，在 Linux 系统下，可以使用以下命令创建名为 libfoo.so 的动态库文件：$ gcc -shared -o libfoo.so foo1.o foo2.o ...其中，-shared 参数表示生成共享库文件。
（3）在编译器中使用动态库，需要将其链接到目标程序中。
在Linux 系统下，可以使用以下命令编译名为 main.c 的源文件和名为libfoo.so 的动态库文件：$ gcc -o main main.c -L. -lfoo其中，-L 和 -l 参数的含义同静态库。
c语言中库的定义等相关概念 -回复
c语言中库的定义等相关概念-回复C语言中的库（Library）是指一组预先编写好的可重用的代码，这些代码包含了各种功能，如输入输出、字符串处理、数学运算等。
库可以被其他程序调用，以提高开发效率和代码复用性。
本文将逐步解释库的定义，库的类型，库的使用和实现等相关概念。
定义：库是一种软件资源，其中包含了预先编写好的可重用的代码。
这些代码经过测试和优化，以提供特定功能或解决特定问题。
库可以作为单个文件或多个文件的集合提供。
C语言中的库分为两种类型：静态库和动态库。
库的类型：1. 静态库（Static Library）：静态库也称为静态链接库，它在编译时被链接到可执行文件中。
静态库包含了预编译好的目标代码，这些代码可以直接在编译阶段与程序的其他模块进行链接。
静态库的优点是可移植性强，不依赖于特定的运行环境。
然而，静态库的缺点是占用磁盘空间较大，每个可执行文件都会包含一份完整的库代码。
2. 动态库（Dynamic Library）：动态库也称为共享库或动态链接库，它在程序运行时被加载到内存中。
动态库的代码可以被多个程序共享，从而节省了系统资源。
动态库的优点是占用磁盘空间较小，可以在运行时动态加载和卸载。
然而，动态库的缺点是可能会导致版本兼容性问题和依赖关系管理较为复杂。
库的使用：使用库的步骤如下：1. 引入头文件（Include Header File）：在需要使用库中函数或变量的源代码文件中，通过#include指令包含库的头文件。
头文件包含了库中函数和变量的声明。
示例代码如下：c#include <stdio.h>2. 链接库文件（Link Library File）：在编译可执行文件时，需要将库的目标代码与程序的其他模块进行链接。
对于静态库，可以使用编译器提供的静态链接选项进行链接。
对于动态库，可以使用编译器提供的动态链接选项进行链接。
示例代码如下：gcc main.c -lmath 链接静态库gcc main.c -lmath 链接动态库3. 调用库中的函数（Call Functions）：在源代码文件中，可以通过函数名直接调用库中的函数，并传递参数。
详解C语言中的lib文件
lib有静态lib和动态lib之分。
在Windows上，lib的后缀为lib，在Linux上，静态lib的后缀为a 和动态lib后缀为so。
编辑本段lib使用静态lib将导出声明和实现都放在lib中。
编译后所有代码都嵌入到宿主程序动态lib相当于一个h文件，是对实现部分（.dll文件）的导出部分的声明。
编译后只是将导出声明部分编译到宿主程序中，运行时候需要相应的dll文件支持lib文件是不对外公开的，不能查看一个编译过后的文件有几个选择：1。
如果你查看有同名的dll文件，可以通过vc自带的depends查看dll 接口2。
通过msdn看你使用的该lib包含的函数名，来查找其对应的头文件，头文件里面有整个lib的函数声明（可能不全）3。
查看vc或者其他工具安装目录下的src目录，查看函数的代码lib文件是二进制文件，所以要查看它的内容，只能反汇编。
用编程语言,打开lib文件的办法有三个:1、在object/library modules使用全路径名；2、把*.lib放在VC的Lib目录中3、修改project setting的Link->Input中的Addtional library path，加入你的目录LIB文件是库文件（与DLL文件相类似），供其它程序调用的，直接打不开。
用编程语言,打开lib文件的办法有三个，使用哪个都行：1、在object/library modules使用全路径名；2、把*.lib放在VC的Lib目录中3、修改project setting的Link->Input中的Addtional library path，加入你的目录。
lib文件操作一个lib文件是obj文件的集合。
当然，其中还夹杂着其他一些辅助信息，目的是为了让编译器能够准确找到对应的obj文件。
我们可以通过tlib.exe（在tc2.0下的根目录）来对lib文件进行操作，你可以把自己生成的obj文件通过tlib命令加入到一个lib文件中，也可以把lib文件内的obj文件进行删除操作，还可以把内部的obj文件给提取出来。
Qt中添加静态库.lb,.a和动态库.dll,.so，头文件和.cpp文件
Qt中添加静态库.lb,.a和动态库.dll,.so，头⽂件和.cpp⽂件添加步骤1.-Qt Creator中，"项⽬"------"添加库"2.把静态库和动态库⽂件放到项⽬⽂件夹中3.在.pro⽂件中会添加如下代码：- 添加动态库：如：lipsap.so (不需要添加路径)LIBS+=-LPWD/......l(指定库的名称)（熟悉Linux语⾔的知道，PWD是当前路径的意思）−添加静态库：（修改⼀下）如：halcon.awin32:LIBS+= PWD/lib....../-lhalcon (不⽤带后缀⽂件名)//项⽬⽂件夹的路径INCLUDEPATH+=$$PWD/include//头⽂件所在的路径DEPENDPATH+=$$PWD/include（添加过后会多两⾏.h⽂件的路径）如果是Linux操作系统，则是：linux:LIBS+= -L$$PWD/.....注意：⼀般.lib⽂件类似于.cpp⽂件，需要⼀个.h⽂件作为接⼝！因此添加.lib⽂件时是要有.h⽂件！⼀般.dll⽂件会有.lib⽂件和.h⽂件2个作为接⼝！因此要添加.h⽂件所在路径和.lib⽂件作为接⼝！4.添加.h和.cpp⽂件（完全开源的）- 先在项⽬⽂件中添加⼀个⽂件夹，include把.h和.cpp⽂件拷贝进去- 添加现有项⽬会发现.pro⽂件中SOURCES和HEADERS中⾃动添加了关于LIBS变量的说明-L 指定库名称-l 指定库名称（⼩写的l）⽆需后缀名，对.so,.a,.dll,.lib都适⽤如果不带-l，则带后缀名即：LIBS += -LD:/codetest/lib/-lws2_32等同于LIBS += D:/codetest/lib/ws2_32.lib也等同于LIBS += -L$$PWD/-lws2_32也等同于LIBS += -L$$PWD/ws2_32.libProcessing math: 100%。
gcc用法
gcc用法gcc是GNU Compiler Collection的缩写，是一个集成的编译器系统，支持多种编程语言，包括C、C++、Objective-C、Fortran、Java等。
以下是一些常见的gcc用法：1. 编译源代码gcc main.c -o myprogram以上命令将会编译main.c文件，并生成可执行文件myprogram。
2. 编译多个源代码文件gcc file1.c file2.c -o myprogram以上命令将会编译file1.c和file2.c文件，并生成可执行文件myprogram。
3. 编译静态库gcc -c file1.c file2.car rcs libmylib.a file1.o file2.o以上命令将会编译file1.c和file2.c文件，并将它们打包成静态库libmylib.a。
4. 编译动态库gcc -shared -o libmylib.so file1.o file2.o以上命令将会编译file1.o和file2.o文件，并将它们打包成动态库libmylib.so。
5. 调试程序gcc -g main.c -o myprogram以上命令将会编译main.c文件并为其加入调试信息，从而便于程序调试。
6. 优化编译gcc -O2 main.c -o myprogram以上命令将会以O2优化等级编译main.c文件，并尝试优化生成的可执行文件。
7. 链接外部库gcc main.c -o myprogram -lm以上命令将会编译main.c文件，并链接数学库libm.a，从而使程序可以使用数学函数。
以上是一些常见的gcc用法，还有许多其它用法可以通过man gcc命令查看详细用法。
编辑编译连接执行过程中对应的文件扩展名
编辑编译连接执行过程中对应的文件扩展名在编写、编译、连接和执行程序的过程中，不同的文件扩展名用于标识不同类型的文件。
下面是一些常见的文件扩展名及其相应的用途：
1. 源代码文件扩展名：
- .c：C语言源代码文件
- .cpp：C++语言源代码文件
- .java：Java语言源代码文件
- .py：Python语言源代码文件
- .html：HTML网页源代码文件
2. 目标文件扩展名：
- .o：目标文件，包含已编译但未链接的二进制代码
- .obj：Windows系统上的目标文件
- .class：Java字节码文件
3. 库文件扩展名：
- .a：静态库文件（在Unix和Linux系统中）
- .lib：静态库文件（在Windows系统中）
- .so：共享库文件（在Unix和Linux系统中）
- .dll：动态链接库文件（在Windows系统中）
4. 可执行文件扩展名：
- .exe：Windows可执行文件
- .out：Unix和Linux可执行文件
- .app：MacOS可执行文件
除了这些常见的文件扩展名之外，还有一些特定于某些开发环境或语言的扩展名。
例如，对于Web开发，还有.css（样式表文件）、.js （JavaScript文件）和.php（PHP脚本文件）。
对于数据库开发，还有.sql（SQL脚本文件）。
这些扩展名用于标识特定类型的文件，并告诉编译器、连接器和操作系统如何处理它们。
在编写程序时，应根据所使用的编程语言和工具链的要求为文件选择正确的扩展名。
这样可以确保编译、连接和执行过程能够正确进行，并且生成正确的可执行文件或库文件。
动态库依赖动态库，静态库依赖静态库，顺序
动态库依赖动态库，静态库依赖静态库，顺序静态库依赖静态库，有顺序的问题，否则undefined reference⾄于动态链接，链接器会对依赖进⾏整理，避免这个问题。
动态库就不存在依赖顺序的问题。
如果库是相互独⽴的，则顺序不重要。
如果不是相互独⽴，那么必须对它们进⾏排序对于⽇常命令⾏编译命令，⼀般从左到右分别是可执⾏⽂件 ——> ⾼级库 ——> 底层库，避免循环依赖；越是底层的库，越是往后⾯写，可以参考下述命令通式：g++ ... obj($?) -l(上层逻辑lib) -l(中间封装lib) -l(基础lib) -l(系统lib) -o $@静态库有顺序问题，并且要把⾃⼰的库所依赖的所有的第三⽅库都要显⽰的指定出来。
动态库⽆顺序问题，并且只需要显⽰的连接⾃⼰的动态库，⾃⼰的动态库依赖的第三⽅的动态库⽆需显⽰指定，⾃⼰会从rpath中⾃动连接第三⽅的动态库。
但必须把第三⽅库依赖的所有的库，包括路径都拷贝出来。
例如使⽤libevent.so, 此时需要把下⾯这⼀堆⽂件都拷贝出来：lrwxrwxrwx. 1 root root 21 Mar 25 15:18 deps/so/libevent-2.1.so.7 -> libevent-2.1.so.7.0.1-rwxr-xr-x. 1 root root 386024 Mar 25 15:18 deps/so/libevent-2.1.so.7.0.1lrwxrwxrwx. 1 root root 26 Mar 25 15:17 deps/so/libevent_core-2.1.so.7 -> libevent_core-2.1.so.7.0.1-rwxr-xr-x. 1 root root 241936 Mar 25 15:17 deps/so/libevent_core-2.1.so.7.0.1lrwxrwxrwx. 1 root root 26 Mar 25 15:17 deps/so/libevent_core.so -> libevent_core-2.1.so.7.0.1lrwxrwxrwx. 1 root root 21 Mar 25 15:18 deps/so/libevent.so -> libevent-2.1.so.7.0.1把第三⽅静态库链接到⾃⼰的.so动态库，编译第三⽅静态库的时候需要加 -fPIC这个参数。
C语言动态库与静态库区别
C语言动态库与静态库区别在C语言开发中，库（Library）是一种可重用的代码模块，它包含了一系列已经编译的函数和数据，用于帮助开发人员快速完成特定的任务。
库分为动态库和静态库两种形式，它们在使用方式和编译过程中存在一些显著的区别。
一、动态库（Dynamic Library）动态库也被称为共享库（Shared Library），其扩展名一般为“.so”（在Windows系统下为“.dll”）。
动态库在程序运行时被加载到内存，可以被多个程序实例共享，使得内存利用率更高。
而且，由于动态库在编译时并未与目标程序绑定，因此可以通过动态链接器在程序运行时加载、卸载和更新，具有更高的灵活性。
动态库的特点如下：1. 内存占用：动态库在程序运行时才会被加载到内存，因此不会增加目标程序的体积。
多个程序实例可以共享同一个动态库，节省内存空间。
2. 更新维护：对于动态库的更新和维护，只需要替换库文件即可，无需重新编译目标程序。
3. 运行时加载：动态库的加载和卸载是在程序运行时完成的，可以根据需要进行动态加载和卸载，提高程序的灵活性。
4. 共享性：多个程序实例可以同时使用同一个动态库，提高代码的重用性，并且减少了库文件的重复。
二、静态库（Static Library）静态库是在编译目标程序时，将库的代码和数据直接复制到目标程序中。
静态库的文件扩展名通常为“.a”（在Windows系统下为“.lib”）。
由于静态库在编译时与目标程序绑定，因此静态库的代码和数据会被完整复制到每一个使用该库的程序中。
静态库的特点如下：1. 执行速度：由于静态库的代码和数据完全被复制到了目标程序中，因此在执行过程中不需要进行动态加载，执行速度相对较快。
2. 独立性：每一个使用该库的程序都包含了静态库的完整副本，因此静态库程序可以独立运行，无需依赖其他库文件。
3. 目标文件较大：由于静态库代码和数据完全被复制到目标程序中，所以会导致目标文件体积较大。
程序文件格式
程序文件格式概述程序文件格式是指计算机程序在存储介质上的存储方式和组织结构。
不同的程序文件格式有不同的规范和特点，对于程序开发和执行都具有重要的意义。
程序文件格式的选择和使用能够影响程序的可移植性、可读性和性能。
常见的程序文件格式1. 可执行文件（Executable File）可执行文件是一种包含可直接在操作系统上执行的代码的二进制文件。
它通常包含有机器代码、数据段、代码段和符号表等信息。
可执行文件的格式因操作系统的不同而有所差异，如Windows中的EXE格式、Linux中的ELF格式等。
2. 源代码文件（Source Code File）源代码文件是程序员编写的纯文本文件，包含了程序的源代码。
它们通常以特定的扩展名为后缀，如C语言的“.c”文件、Java的“.java”文件等。
源代码文件在开发过程中扮演着关键的角色，它们需要通过编译器或解释器进行编译或解释才能生成可执行文件。
3. 库文件（Library File）库文件是一种包含在程序开发中常用的函数、类和方法等可重用代码的二进制文件。
它们通常分为静态库（Static Library）和动态库（Dynamic Library）。
静态库在连接时被整合到可执行文件中，而动态库则在程序运行时被加载。
常见的库文件格式有Windows中的LIB和DLL格式、Linux中的SO格式等。
4. 配置文件（Configuration File）配置文件是用于配置程序运行环境的文本文件。
它们包含了程序运行所需的各种参数和设置。
配置文件的格式因程序的不同而有所区别，如INI格式、XML格式、JSON格式等。
通过修改配置文件，可以改变程序的行为和性能，提高程序的灵活性。
5. 数据文件（Data File）数据文件是用于存储程序运行时所需数据的文件。
它们通常包含了程序需要读取或写入的数据。
数据文件的格式取决于所存储数据的特性和要求。
常见的数据文件格式有文本文件、CSV格式、XML格式、JSON格式等。
头文件和库文件-静态库和动态库
头⽂件和库⽂件-静态库和动态库⼀、头⽂件和库⽂件头⽂件提供声明，库⽂件提供定义/实现。
C代码的编译过程: 预处理(需要头⽂件) -> 编译 -> 汇编 -> 链接(需要库⽂件); 执⾏时可能还有动态链接过程。
编译的时候，只要有头⽂件中的声明就⾜够了。
在链接的时候，把已经编译好的.obj和现有的.lib⽂件进⾏链接，这时就可以最终⽣成可执⾏⽂件了。
其实头⽂件与其实现⽂件或相应lib⽂件都没有直接的联系。
头⽂件是告诉编译器函数是如何去调⽤如何返回的，所有实现都是分别编译，最后在链接阶段链在⼀起。
头⽂件包含声明, 库⽂件包含实现或者与DLL库的连接所以,如果在代码⾥要⽤到这些函数那么就要包含头⽂件,编译的时候才能知道这些函数的原形;在进⾏代码连接的时候就需要库⽂件了,这时连接器就把函数的实现代码(静态库)连接到你的程序或者将你的函数调⽤连接到相应的DLL的对应函数(动态库)lib是静态库, 编译的时候代码直接插⼊到你的程序 ,DLL是动态库,编译的时候,只是产⽣⼀些调⽤DLL内代码的导⼊表,真正运⾏的时候是调⽤的DLL内的代码。
总结起来就是，库⽂件通过头⽂件向外导出接⼝。
⽤户通过头⽂件找到库⽂件中函数实现的代码从⽽把这段代码链接到⽤户程序中去。
.a代表传统的静态函数库(也称作归档⽂件：archive).so代表共享函数库⼆、创建静态库⽂件：1.创建源⽂件willku1.c和willku2.c2.编译源⽂件⽣成.o⽂件（将要包含在库⽂件中的⽬标⽂件）gcc -c willku1.c willku2.c =>willku1.o willku2.o3.创建头⽂件ishead.h内容：void willku1(char *);void willku2(int);4.创建应⽤程序app.c（将调⽤willku2.c⽂件）#include "ishead.h"5.编译、测试应⽤程序app.cgcc -c app.cgcc -o app app.o willku2.o./app6.创建并使⽤库⽂件（.a）,使⽤ar创建归档⽂件并将⽬标⽂件加进去。
vs编译动态链接库和静态链接库的方法
vs编译动态链接库和静态链接库的方法在Visual Studio（VS）中编译动态链接库（DLL）和静态链接库（LIB）的方法略有不同。
以下是具体的步骤：编译动态链接库（DLL）1. 打开Visual Studio。
2. 创建一个新的项目。
在“新建项目”对话框中，选择“DLL项目模板”（通常在“Visual C++” -> “Windows桌面”下）。
3. 在项目属性中，设置“配置属性” -> “常规” -> “配置类型”为“动态库(.dll)”。
4. 编写你的代码。
DLL的入口点通常是一个导出函数，例如`__declspec(dllexport) void MyFunction()`。
5. 编译项目。
编译成功后，你会得到一个DLL文件。
编译静态链接库（LIB）1. 打开Visual Studio。
2. 创建一个新的项目。
在“新建项目”对话框中，选择“静态库项目模板”（通常在“Visual C++” -> “通用”下）。
3. 编写你的代码。
LIB不要求特别的入口点，但你需要确保所有的函数和变量都被正确地声明为`__declspec(dllexport)`或`__declspec(dllimport)`。
4. 编译项目。
编译成功后，你会得到一个LIB文件和一个PDB文件。
PDB 文件包含了程序数据库信息，用于源码级别的调试。
请注意，以上步骤可能会因Visual Studio的不同版本和设置有所不同。
如果你遇到任何问题，建议查阅Visual Studio的官方文档或寻求在线帮助。
关于静态链接库(Lib)与动态链接库(DLL)
关于静态链接库(Lib)与动态链接库(DLL)静态链接库（Lib）和动态链接库（DLL）的问题困扰了我很长时间，而当中关键的问题是两者有何联系？又有何区别呢？怎么创建？怎么使用？使用的过程中要注意什么？一直想把这个问题总结一下。
在windows下一般可以看到后缀为dll和后缀为lib的文件，但这两种文件可以分为三种库，分别是动态链接库（Dyna mic-Link Libraries），目标库（Object Li braries）和导入库（Import Libra ries），下面一一解释这三种库。
目标库（Object Li braries）目标库又叫静态链接库，是扩展名为.LIB的文件，包括了用户程序要用到的各种函数。
它在用户程序进行链接时，“静态链接”到可执行程序文件当中。
例如，在V C++中最常使用到的C运行时目标库文件就是LIB C.LIB。
在链接应用程序时常使用所谓“静态链接”的方法，即将各个目标文件(.obj)、运行时函数库(.lib)以及已编译的资源文件(.res)链接到一起，形成一个可执行文件(.exe)。
使用静态链接时，可执行文件需要使用的各种函数和资源都已包含到文件中。
这样做的缺点是对于多个程序都使用的相同函数和资源要重复链接到exe文件中，使程序变大、占用内存增加。
导入库（I mport Li braries）导入库是一种特殊形式的目标库文件形式。
和目标库文件一样，导入库文件的扩展名也是.LIB，也是在用户程序被链接时，被“静态链接”到可执行文件当中。
但是不同的是，导入库文件中并不包含有程序代码。
相应的，它包含了相关的链接信息，帮助应用程序在可执行文件中建立起正确的对应于动态链接库的重定向表。
比如KERNEL32.LIB、USER32.LIB和GDI32.LIB就是我们常用到的导入库，通过它们，我们就可以调用Windows提供的函数了。
如果我们在程序中使用到了Rec tangle这个函数，GDI32.LIB就可以告诉链接器，这个函数在GDI32.DLL动态链接库文件中。
lib静态库与动态库
先删除 除.c和.h外的 所有文件，恢复成我们刚刚编辑完举例程序状态。
# rm -f hello hello.o /usr/lib/libmyhello.so
# ls
hello.c hello.h main.c
#
在来创建静态库文件libmyhello.a和动态库文件libmyhello.so。
#
我们删除静态库文件试试公用函数hello是否真的连接到目标文件 hello中了。
# rm libmyhello.a
rm: remove regular file `libmyhello.a'? y
# ./hello
Hello everyone!
#
程序照常运行，静态库中的公用函数已经连接到目标文件中了。
7.可执行程序在执行的时候如何定位共享库文件
当系统加载可执行代码时候，能够知道其所依赖的库的名字，但是还需要知道绝对路径
此时就需要系统动态载入器(dynamic linker/loader)
对于elf格式的可执行程序，是由ld-linux.so*来完成的，它先后搜索elf文件的 DT_RPATH段—环境变量LD_LIBRARY_PATH—/etc/ld.so.cache文件列表—/lib/,/usr/lib目录找到库文件后将其载入内存
# mv libmyhello.so /usr/lib
# ./hello
./hello: error while loading shared libraries: /usr/lib/libhello.so: cannot restore segment prot after reloc: Permission denied
1.什么是库
在windows平台和linux平台下都大量存在着库。
动态链接库及静态链接库（windows下的.dll.lib和linux下的.so.a）
动态链接库及静态链接库（window s下的.dll .lib和li nux下的.so .a）库有动态与静态两种，动态通常用.so为后缀，静态用.a为后缀。
例如：libhel lo.so libhel lo.a 为了在同一系统中使用不同版本的库，可以在库文件名后加上版本号为后缀,例如：libhel lo.so.1.0,由于程序连接默认以.so为文件后缀名。
所以为了使用这些库，通常使用建立符号连接的方式。
ln -s libhel lo.so.1.0 libhel lo.so.1ln -s libhel lo.so.1 libhel lo.so使用库当要使用静态的程序库时，连接器会找出程序所需的函数，然后将它们拷贝到执行文件，由于这种拷贝是完整的，所以一旦连接成功，静态程序库也就不再需要了。
然而，对动态库而言，就不是这样。
动态库会在执行程序内留下一个标记…指明当程序执行时，首先必须载入这个库。
由于动态库节省空间，linux下进行连接的缺省操作是首先连接动态库，也就是说，如果同时存在静态和动态库，不特别指定的话，将与动态库相连接。
现在假设有一个叫hel lo的程序开发包，它提供一个静态库lib hello.a 一个动态库l ibhel lo.so,一个头文件h ello.h,头文件中提供sayhe llo()这个函数/* hello.h */void sayhel lo();另外还有一些说明文档。
这一个典型的程序开发包结构1.与动态库连接linux默认的就是与动态库连接，下面这段程序testl ib.c使用hel lo库中的sayhe llo()函数/*testli b.c*/#includ e#includ eint main(){sayhel lo();return 0;}使用如下命令进行编译$gcc -c testli b.c -o testli b.o用如下命令连接：$gcc testli b.o -lhello -o testli b在连接时要注意，假设libh ello.o 和libhe llo.a都在缺省的库搜索路径下/usr/lib下，如果在其它位置要加上-L参数与与静态库连接麻烦一些，主要是参数问题。
lib和dll文件的区别和联系
lib和dll文件的区别和联系分类：C/C++ 2013-07-23 12:38 142人阅读评论(0) 收藏举报libdll共有两种库：一种是LIB包含了函数所在的DLL文件和文件中函数位置的信息（入口），代码由运行时加载在进程空间中的DLL提供，称为动态链接库dynamic link library。
一种是LIB包含函数代码本身，在编译时直接将代码加入程序当中，称为静态链接库static link library。
共有两种链接方式：动态链接使用动态链接库，允许可执行模块（.dll文件或.exe文件）仅包含在运行时定位DLL函数的可执行代码所需的信息。
静态链接使用静态链接库，链接器从静态链接库LIB获取所有被引用函数，并将库同代码一起放到可执行文件中。
关于lib和dll的区别如下：（1）lib是编译时用到的，dll是运行时用到的。
如果要完成源代码的编译，只需要lib；如果要使动态链接的程序运行起来，只需要dll。
（2）如果有dll文件，那么lib一般是一些索引信息，记录了dll中函数的入口和位置，dll 中是函数的具体内容；如果只有lib文件，那么这个lib文件是静态编译出来的，索引和实现都在其中。
使用静态编译的lib文件，在运行程序时不需要再挂动态库，缺点是导致应用程序比较大，而且失去了动态库的灵活性，发布新版本时要发布新的应用程序才行。
（3）动态链接的情况下，有两个文件：一个是LIB文件，一个是DLL文件。
LIB包含被DLL 导出的函数名称和位置，DLL包含实际的函数和数据，应用程序使用LIB文件链接到DLL文件。
在应用程序的可执行文件中，存放的不是被调用的函数代码，而是DLL中相应函数代码的地址，从而节省了内存资源。
DLL和LIB文件必须随应用程序一起发行，否则应用程序会产生错误。
如果不想用lib文件或者没有lib文件，可以用WIN32 API函数LoadLibrary、GetProcAddress装载。
动态链接库及静态链接库(windows下的.dll .lib和linux下的.so .a)
动态链接库及静态链接库（windows下的.dll .lib和linux下的.so .a）库有动态与静态两种，动态通常用.so为后缀，静态用.a为后缀。
例如：libhello.so libhello.a 为了在同一系统中使用不同版本的库，可以在库文件名后加上版本号为后缀,例如：libhello.so.1.0,由于程序连接默认以.so为文件后缀名。
所以为了使用这些库，通常使用建立符号连接的方式。
ln -s libhello.so.1.0 libhello.so.1ln -s libhello.so.1 libhello.so使用库当要使用静态的程序库时，连接器会找出程序所需的函数，然后将它们拷贝到执行文件，由于这种拷贝是完整的，所以一旦连接成功，静态程序库也就不再需要了。
然而，对动态库而言，就不是这样。
动态库会在执行程序内留下一个标记…指明当程序执行时，首先必须载入这个库。
由于动态库节省空间，linux下进行连接的缺省操作是首先连接动态库，也就是说，如果同时存在静态和动态库，不特别指定的话，将与动态库相连接。
现在假设有一个叫hello的程序开发包，它提供一个静态库libhello.a 一个动态库libhello.so,一个头文件hello.h,头文件中提供sayhello()这个函数/* hello.h */void sayhello();另外还有一些说明文档。
这一个典型的程序开发包结构1.与动态库连接linux默认的就是与动态库连接，下面这段程序testlib.c使用hello库中的sayhello()函数/*testlib.c*/#include#includeint main(){sayhello();return 0;}使用如下命令进行编译$gcc -c testlib.c -o testlib.o用如下命令连接：$gcc testlib.o -lhello -o testlib在连接时要注意，假设libhello.o 和libhello.a都在缺省的库搜索路径下/usr/lib下，如果在其它位置要加上-L参数与与静态库连接麻烦一些，主要是参数问题。
DLL动态链接库和LIB静态链接库
1：神马是Dll和Lib，神马是静态链接和动态链接大家都懂的，DLL就是动态链接库，LIB是静态链接库。
DLL其实就是EXE，只不过没main。
动态链接是相对于静态链接而言的。
所谓静态链接就是把函数或过程直接链接到可执行文件中，成为可执行程序中的一部分，当多个程序调用同样的函数时，内存里就会有这个函数的多个拷贝，浪费内存资源。
而动态链接则是提供了一个函数的描述信息给可执行文件（并没有内存拷贝），当程序被夹在到内存里开始运行的时候，系统会在底层创建DLL和应用程序之间的连接关系，当执行期间需要调用DLL函数时，系统才会真正根据链接的定位信息去执行DLL中的函数代码。
在WINDOWS32系统底下，每个进程有自己的32位的线性地址空间，若一个DLL被进程使用，则该DLL首先会被调入WIN32系统的全局堆栈，然后通过内存映射文件方式映射到这个DLL的进程地址空间。
若一个DLL被多个进程调用，则每个进程都会接收到该DLL的一个映像，而非多份的拷贝。
但，在WIN16系统下，每个进程需要拥有自己的一份DLL空间，可以理解为何静态链接没啥区别。
2：DLL和LIB区别和联系。
DLL是程序在运行阶段才需要的文件。
LIB是程序编译时需要链接的文件。
DLL只有一种，其中一定是函数和过程的实现。
LIB是有两种。
若只生成LIB的话，则这个LIB是静态编译出来的，它内部包含了函数索引以及实现，这个LIB会比较大。
若生成DLL的话，则也会生成一个LIB，这个LIB和刚才那个LIB不同，它是只有函数索引，没有实现的，它很小。
但是这俩LIB依然遵循上个原则，是在编译时候是需要被链接的。
若不链接第一个LIB的话，在程序运行时会无法找到函数实现，当掉。
若不链接第二个LIB的话，在程序运行时依然会无法找到函数实现。
但第二种LIB 有一种替代方式，就是在程序里，使用LoadLibrary,GetProcAddress替代第二个LIB的功能。
c语言源程序经过编译程序编译后所产生的文件扩展名
c语言源程序经过编译程序编译后所产生的文件扩展名在撰写这篇文章之前，让我们首先来深入探讨一下C语言源程序经过编译程序编译后所产生的文件扩展名。
C语言作为一种高级程序设计语言，其源代码需要通过编译器进行编译后才能生成可执行文件。
而在编译过程中，会产生一些特定的文件扩展名，我们将从简到繁地来讨论这个主题。
1. .c源文件我们需要了解的是C语言源程序文件的扩展名为.c。
在编写C语言程序时，我们通常将源代码保存为以.c为后缀的文件，比如hello.c、main.c等。
这些.c文件包含了完整的C语言代码，需要通过编译器将其转换为机器语言才能执行。
2. .obj目标文件在进行编译时，编译器会将.c文件编译生成目标文件，其文件扩展名通常为.obj。
目标文件是编译器输出的中间文件，包含了编译后的机器语言代码和一些符号表等信息，但还不能直接作为可执行文件运行。
3. .exe可执行文件经过连接器的处理，将目标文件连接生成可执行文件，其文件扩展名为.exe。
可执行文件包含了机器语言代码和连接器生成的一些其他信息，可以直接在操作系统中执行，完成程序的运行。
4. .o目标文件和.a库文件在Unix/Linux系统中，编译生成的目标文件通常以.o为扩展名，而库文件通常以.a为扩展名。
这与Windows系统的.obj和.exe略有不同，但本质相同，都是编译和连接生成的文件。
5. 综述C语言源程序经过编译程序编译后所产生的文件扩展名包括.c、.obj （.o）、.exe以及.a等。
这些文件扩展名代表了C语言程序经过编译、连接等阶段生成的不同类型文件，对于我们理解程序编译过程及调试程序都有着重要的意义。
6. 个人观点和理解个人认为，了解C语言源程序编译后所产生的文件扩展名是非常重要的，这有助于我们深入理解程序编译连接的过程，也有助于我们更好地进行程序调试和优化。
对于想要深入学习C语言的初学者来说，掌握这些知识也是基础中的基础。
通过本文的讨论，希望读者能对C语言源程序编译后所产生的文件扩展名有更深入的理解，从而在编程学习和实践中能够更加得心应手。
Dll动态库和静态库LIB
1、动态库只有导出才能使用2、可以导出函数也可以导出类，可以导出类的个别函数，如果导出类则等于导出了其所有成员。
3、_declspec(dllimport)4、使用宏定义#ifdef DLL1_API#else#define DLL1_API _declspec(dllimport)#endifDLL1_API int add(int a,int b);DLL1_API int subtract(int a,int b);class DLL1_API Point{public:void OutPut(int x,int y);};5、生成两个文件.dll .lib6、动态库的使用，在VC中包含导入库lib#pragma comment(lib,"dll1.lib")将.dll 拷贝到程序目录中导入函数或类_declspec(dllimport) int add(int a,int b);直接包含头文件#pragma comment(lib,"dll1.lib")#include "dll1.h"7、直接使用CString str;str.Format("5+3=%d",add(5,3));MessageBox(str);Point pt;pt.OutPut(2,3);应为已经有了它们的声明。
8、工具D:\Program Files\Microsoft V isual Studio\VC98\Bin\dumpbin.exe查看导入、导出的函数9、扩展，函数调用方式，版本兼容问题静态库1、同上新建一个win32的lib工程，写些函数，编译生成lib文件2、将lib文件和.h头文件拷贝到新VC工程中，导入lib，包含.h。
3、直接调用函数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
静态库的编译和使用
若干静态库中使用了 module，那么编译还会产生 mod 文件。 每一个 module 对应一个同名的 mod 文件 mod 文件可以认为是 module 的“概述”，与 C 语言的“头文件”作用相似 但与 C 语言需要自己书写头文件不同，Fortran的 mod 文件由编译器自动生成
当 use Module 时，编译器需要能够找到对应的 mod 文件。 因此，有必要把静态库里产生的 mod 文件保存起来，以便使用静态库时加载
目录
1
什么是lib和dll？
2 静态库的编译和使用
3 动态库的编译和使用
动态库的编译和使用
动态库 DLL，实际上也是可执行文件，与 exe 本质上是一样的。 只不过 dll 通常没有主程序而已。它必须由 exe 在运行以后调用。
易于更新 易于被察觉
代码被多次编译
多个程序使用相同的被拷贝 成多份的代码段
多个程序使用同一份 代码
目录
1
什么是lib和dll？
2 静态库的编译和使用
3 动态库的编译和使用
静态库的编译和使用
静态库 lib，实际上，就是 obj 文件的集合。可以认为是打包在一起的若干 obj 因此它的编译过程是： 1. 编译子程序源代码，得到若干 obj 文件 2. 打包这些 obj 文件，成为 lib 静态库 它的使用过程也比较简单： 编译主程序（或其他子程序），链接时，带上 lib 文件即可
动态库的编译和使用
这两种方法也各有特点：
利用导入库 lib 确定了一定会使用该DLL 如果DLL不存在，则程序无法运行
大多数时候使用该方式
可被 dependency walker 或 ldd 等程序侦察到
利用系统函数动态加载
不一定会用到该 DLL 如果DLL不存在，加载函数会失败
程序可进入另一个执行分支 特别适合书写插件，可选功能
此外，第三方的函数库，例如 IMSL，MKL，Lapack 等，也有lib和dll的形式 如果涉及与其他语言的混编，也经常用到lib和dll
什么是lib和dll？
源代码，lib 和 dll 各有自己的特点：
源代码
lib 静态库（.a）
dll 动态库(.so)
使用者容易修改
使用者不易修改
不易更新，需重新编译 不易被察觉
关于 Fortran Coder
Fortran Coder 始于2006年，是一个以科学计算编程为主题的非盈利性 研讨团体。大多数由各行业高等学府学生，研究人员及生产一线的工作 人员组成。
研讨内容涉及：Fortran77/90/95/2003/2008语法规范，各平台32位及64位编译器，IMSL， MKL，Lapack 等数学函数库，MPI，OpenMP，Coarray 并行及高性能计算，winteracter / DisLin / Matfor / GTKFortran 等绘图及界面库。
我们也不妨多搜集一些他人分享出的劳动结果，在自己的程序里直接使用。 当然我们也可以把我们的代码分享（甚至销售）给其他人。 除了源代码形式的分享外，lib 和 dll 也是常见的分享方式。 我们也可以把一系列（相关联的）函数，封装成 lib /dll 库，以方便自己使用。
什么是lib和dll？
编译
链接
关于 lib 和 dll 的一个比喻：
导入库 lib
什么是lib和dll？
我们的编译器自身，其实就用到了很多静态库和动态库。 很多编译器的运行时库，其实就是“静态库”，甚至可能是“动态库” 比如，IVF 的 ifconsol.lib , ifcoremmd.dll GFortran 的 libc.so libgfortran.so , Silverfrost Ftn95 的 salflibc.dll
本套视频由 Fortran Coder 研讨团队录制，供所有 Fortran 程序员和学习者免费自由的观看，您可 随意的传播它。但请保证视频完整性。
我们将会不定期的更新本套视频，请持续关注我们的网站、QQ群！ 同时，如果您对 Fortran 相关有自己的见解，并愿意通过录制视频的方式与其 他人分享，请联系我们！
什么是lib和dll？ห้องสมุดไป่ตู้
源代码分享，就是把源代码直接拿出去，下次使用时添加在新的工程内：
什么是lib和dll？
静态库 lib 就是先把部分源代码编译，并打包成静态库，以后的工程直接链接：
什么是lib和dll？
动态库 dll 就是先把部分源代码编译并链接成动态库，以后的工程可以依赖它运行：
什么是lib和dll？
由于 DLL 具有良好的可维护性，节约内存等特点。 在 windows，linux，mac 等操作系统上，都大量的使用了 DLL 动态库。
动态库的编译和使用
动态库 dll，实际上，是可执行文件。可以认为和 exe 是同类东西 因此它的编译过程是： 1. 编译子程序源代码，得到若干 obj 文件 2. 链接这些 obj 文件（可能包含运行时库一起），得到 DLL 文件 3. 部分平台的编译器会得到导入库 lib 它的使用有两种方法(显示调用，隐式调用)： 1. 编译主程序（或其他子程序），链接时，带上导入库 lib 文件 2. 动态的利用系统函数加载 DLL，如 windows 下的 LoadLibrary 和 GetProcAddress
关于本套视频
本套视频以解决实际问题为主要目的，旨在为您解答课本上较少涉及到的实际 问题。通过本套视频，您会更容易了解：
如何查找错误？如何解决错误？ 如何学习 Fortran2003 和 Fortran2008 语法？ 如何用最通俗易懂的写法解决实际问题？ 如何看懂别人的优秀代码并为自己所用？如何让自己的代码更优美、更普适？
第四讲
应用篇 第 四 讲
静态库和动态链接库
讲解人：雪球 gao@ 讨论QQ群：2338021
目录
1
什么是lib和dll？
2 静态库的编译和使用
3 动态库的编译和使用
什么是lib和dll？
大型程序往往不是一个人的劳动成果。 也不是从头到尾全部由一个人或一个团队书写。 合理利用现有的资源，可以起到事半功倍的效果，非常重要。