Linux静态链接库动态链接库的创建和使用及区别
标题：Linux下静态、动态库（隐式、显式调用）的创建和使用及区别
一、静态链接库的创建与使用：
1、编写add.c 及main.c代码：
/**************************************************************************/ /*add.c*/
int add(int x, int y)
{
return x + y;
return 0;
}
/*************************************************************************/ 然后add.h代码为：
/*add.h*/
#ifndef _ADD_H_
#define _ADD_H_
int add(int, int);
#endif
/***************************************************************************/
main函数代码：
/*main.c*/
#include
int main(void)
{
printf("2+3= %d\n", add(2,3));
return 0;
}
/****************************************************************************** ****/
2、现在首先要明确我们目的是将add.c做成静态链接库，然后main.c调用生成的静态链接库中的add()
(1)将add.c做成静态链接库(创建静态库):
首先将add.c编译成目标文件(add.o文件),如下：
#gcc -c add.c //生成add.o
然后将生成的目标文件(add.o)生成静态库libadd.a：
#ar crv libadd.a add.o //生成libadd.a
(2)静态库做好了，就可以在编译main.c时将静态库链接进去了，接下来就编译生成可执行文件(静态库的使用)：
#gcc -o exe main.c -I. -L. -ladd
//或者#gcc -o exe main.c ./libadd.a
//再或者#gcc -o exe main.c -L. libadd.a
(注：这里的-I/路径, -L/路径, 是通过-I和-L指定对应的库文件名和库文件的路径,这里就是当前目录，
libadd.a就是要用的静态库，这样对应的静态库已经编译到对应的可执行程序中。执行对应的可执行文件
便可以得到对应函数调用的结果。在main.c中不需要包含导出文件的头文件。
上面的(2)分开就是：
1)编译生成对应的目标文件：
#gcc -c -I/home/hcj/xxxxxxxx main.c
2)生成可执行文件：
#gcc -o exe -L/home/hcj/xxxxxxxx main.o libstr.a
还有若主函数是C++程序（即.cpp），则需要在main.cpp中用extern "C"{}包含被调用函数(add.c)的
头文件，编译时用g++编译或者还用gcc编译但需加上一个链接c++库的参数(-lstdc++)
)
(3)最后执行可执行程序：
#./exe
二、动态链接库的创建与使用：
1、把add.c编译生成动态库(创建动态库)：
#gcc -fPIC -c add.c //生成add.o
#gcc -shared -o libadd.so add.o /* 或者#ar crv libadd.so add.o */
(上面两行可以整合成一行：#gcc -fPIC -shared -o libadd.so add.c)
注：-fpic 使输出的对象模块是按照可重定位地址方式生成的(即与位置无关)。
-shared指定把对应的源文件生成对应的动态链接库文件libstr.so文件
2、动态库的使用(动态链接库分：隐式调用和显式调用2种)：
(1)隐式调用：
动态链接库（隐式调用）在代码上与写静态链接库没什么区别，主要是在编译时。
代码编写与静态库一样，不需要包含导出函数的头文件，若主函数是C++程序（即.cpp），则需要在main.cpp中用
extern "C"{}包含被调用函数(add.c)的头文件(这里需要包含头文件是与.cpp和.c混合编译有关，同静态\动态库
无关)，编译时用g++编译或者还用gcc编译但需加上一个链接c++库的参数(-lstdc++)
1)代码编写：与静态库一样
2)编译main.c生成可执行程序(动态库隐式调用的使用):
#gcc -o exe main.c ./libadd.so
(或者#gcc -o exe main.c -L. libadd.so
再或者将libadd.so copy到目录/usr/lib或/lib中，然后执行：
#gcc -o exe main.c libadd.so //此时不需要指定搜索路径
)
注：最直接最简单的方法就是把libadd.so拉到/usr/lib或/lib中去。、
还有一种方法export LD_LIBRARY_PATH=$(pwd)
另外还可以在/etc/ld.so.conf文件里加入我们生成的库的目录，然后执行#/sbin/ldconfig。
/etc/ld.so.conf是非常重要的一个目录，里面存放的是链接器和加载器搜索共享库时要检查的目录，
默认是从/usr/lib /lib中读取的，所以想要顺利运行，我们也可以把我们库的目录加入到这个文件中
并执行/sbin/ldconfig 。另外还有个文件需要了解/etc/ld.so.cache,里面保存了常用的动态函数
库，且会先把他们加载到内存中，因为内存的访问速度远远大于硬盘的访问速度，这样可以提高软件加载
动态函数库的速度了。
3)#./exe
(2)显式调用：
显式调用的动态库的创建与隐式调用相同。（隐式调用与静态库的使用方法一样，不需要包含导出函数的头文件(显式调用
也不用包含头文件)，只需要在编译可执行程序时指定库文件的路径）
显式调用和隐式调用的区别在于：编译可执行程序时需要指定库文件的搜索路径，而显式调用编译可执行程序时不用加上
动态库的搜索路径(因为已经在主函数中包含了库文件的路径)，但是需要增加几个系统调用:
(#include
1）dlopen()
第一个参数：指定共享库的名称，将会在下面位置查找指定的共享库。
－环境变量LD_LIBRARY_PATH列出的用分号间隔的所有目录。
－文件/etc/ld.so.cache中找到的库的列表，用ldconfig维护。
－目录usr/lib。
－目录/lib。
－当前目录。
第二个参数：指定如何打开共享库。
－RTLD_NOW：将共享库中的所有函数加载到内存
－RTLD_LAZY：会推后共享库中的函数的加载操作，直到调用dlsym()时方加载某函数
返回值：返回动态库的句柄
2）dlsym()
调用dlsym时，利用dlopen()返回的共享库的句柄以及函数名称作为参数，返回要加载函数的入口地址。
3）dlclose()
关闭动态链接库
4）dlerror()
该函数用于检查调用共享库的相关函数出现的错误。
如果dlerror返回值不为空,则dlsym执行出错
)
1、编写add.c 及main.c代码：
/**************************************************************************/ /*add.c*/
int add(int x, int y)
{
return x + y;
return 0;
}
/*************************************************************************/ 然后add.h代码为：
/*add.h*/
#ifndef _ADD_H_
#define _ADD_H_
int add(int, int);
#endif
/***************************************************************************/
main函数代码：
/*main.c*/
#include
#include
#define LIB "./libadd.so" //指定动态库路径
int main(void)
{
void *dl;
char *error;
int (*func)();
dl = dlopen(LIB, RTLD_LAZY); /*打开动态链接库*/
if(dl == NULL)
{
printf("Failed load libary\n");
}
error = dlerror(); /*检测错误*/
if(error != NULL)
{
printf("%s\n", error);
return -1;
func = dlsym(dl, "test"); /*获取函数的地址*/
error = dlerror(); /*检测错误*/
if(error != NULL)
{
printf("%s\n", error);
return -1;
}
func(); /*调用动态库中函数*/
dlclose(dl); /*关闭共享库*/
error = dlerror(); /*检测错误*/
if(error != NULL)
{
printf("%s\n", error);
return -1;
}
return 0;
}
/****************************************************************************** ****/
2、编译main.c生成可执行程序,动态库的创建已经在上面讲了(动态库显式调用):
1)#gcc -ldl -o exe mian.c
注意要添加-ldl选项，以使用显式调用相关的函数调用。
可以看到，显式调用的代码看上去要复杂很多，但是却比隐式调用要灵活，我们不必在编译时就确定要加载哪个
动态链接库，可以在运行时再确定，甚至重新加载。
2)#./exe
C C++动态链接库的创建与调用
C/C++中动态链接库的创建和调用 1.动态链接库的创建步骤： 创建Non-MFC DLL动态链接库 1.打开File —> New —> Project选项，选择Win32 Dynamic-Link Library —>sample project —>工程名：DllDemo 2.新建一个.h文件DllDemo.h 并添加如下代码： #ifdef DllDemo_EXPORTS #define DllAPI _declspec(dllexport) #else #define DllAPI _declspec(dllimport) extern “C” // 原样编译 { DllAPI int _stdcall Max(int a,int b); //_stdcall使非C/C++语言内能够调用API } #endif 3.新建一个.cpp文件，并添加如下代码 #include "DllDemo.h" DllAPI int __stdcall Max(int a,int b) { if(a==b) return NULL; else if(a>b) return a; else return b; } 4.编译程序生成动态链接库 1.2 用.def文件创建动态连接库DllDemo.dll 1、删除DllDemo工程中的DllDemo.h文件。 2、在DllDemo.cpp文件头，删除#include DllDemo.h语句。 3、向该工程中加入一个文本文件，命名为DllDemo.def并写入如下语句： LIBRARY MyDll EXPORTS Max@1 4、编译程序生成动态连接库。 2.动态链接库的调用步骤 2.1 隐式调用 1.建立DllCnsTest工程 2.将文件DllDemo.dll、DllDemo.lib拷贝到DllCnsTest工程所在的目录 3.在DllCnsTest中添加如下语句： #define DllAPI _declspec(dllimport) #pragma comment(lib,”DllDemo.lib”) extern “C” { DllAPI int _stdcall Max(int a,int b);
GCC编译动态和静态链接库
我们通常把一些公用函数制作成函数库，供其它程序使用。函数库分为静态库和动态库两种。静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在。本文主要通过举例来说明在Linux中如何创建静态库和动态库，以及使用它们。 在创建函数库前，我们先来准备举例用的源程序，并将函数库的源程序编译成.o文件。 第1步：编辑得到举例的程序--hello.h、hello.c和main.c； hello.c(见程序2)是函数库的源程序，其中包含公用函数hello，该函数将在屏幕上输出"Hello XXX!"。hello.h(见程序1)为该函数库的头文件。main.c(见程序3)为测试库文件的主程序，在主程序中调用了公用函数hello。 1.#ifndef HELLO_H 2.#define HELLO_H 3. 4.void hello(const char *name); 5. 6.#endif //HELLO_H 复制代码 程序1: hello.h 1.#include
第2步：将hello.c编译成.o文件； 无论静态库，还是动态库，都是由.o文件创建的。因此，我们必须将源程序hello.c通过g cc先编译成.o文件。 在系统提示符下键入以下命令得到hello.o文件。 # gcc -c hello.c # 我们运行ls命令看看是否生存了hello.o文件。 # ls hello.c hello.h hello.o main.c # 在ls命令结果中，我们看到了hello.o文件，本步操作完成。 下面我们先来看看如何创建静态库，以及使用它。 第3步：由.o文件创建静态库； 静态库文件名的命名规范是以lib为前缀，紧接着跟静态库名，扩展名为.a。例如：我们将创建的静态库名为myhello，则静态库文件名就是libmyhello.a。在创建和使用静态库时，需要注意这点。创建静态库用ar命令。 在系统提示符下键入以下命令将创建静态库文件libmyhello.a。 # ar crv libmyhello.a hello.o # 我们同样运行ls命令查看结果： # ls hello.c hello.h hello.o libmyhello.a main.c # ls命令结果中有libmyhello.a。 第4步：在程序中使用静态库； 静态库制作完了，如何使用它内部的函数呢？只需要在使用到这些公用函数的源程序中包含这些公用函数的原型声明，然后在用gcc命令生成目标文件时指明静态库名，gcc将会从静态库中将公用函数连接到目标文件中。注意，gcc会在静态库名前加上前缀lib，然后追加
VC++动态链接库创建和调用全过程详解
1.概论 先来阐述一下DLL(Dynamic Linkable Library)的概念，你可以简单的把DLL看成一种仓库，它提供给你一些可以直接拿来用的变量、函数或类。在仓库的发展史上经历了“无库－静态链接库－动态链接库”的时代。 静态链接库与动态链接库都是共享代码的方式，如果采用静态链接库，则无论你愿不愿意，lib中的指令都被直接包含在最终生成的EXE文件中了。但是若使用DLL，该DLL不必被包含在最终EXE文件中，EXE文件执行时可以“动态”地引用和卸载这个与EXE独立的DLL文件。静态链接库和动态链接库的另外一个区别在于静态链接库中不能再包含其他的动态链接库或者静态库，而在动态链接库中还可以再包含其他的动态或静态链接库。 对动态链接库，我们还需建立如下概念： （1）DLL 的编制与具体的编程语言及编译器无关 只要遵循约定的DLL接口规范和调用方式，用各种语言编写的DLL都可以相互调用。譬如Windows提供的系统DLL（其中包括了Windows的API），在任何开发环境中都能被调用，不在乎其是Visual Basic、Visual C++还是Delphi。 （2）动态链接库随处可见 我们在Windows目录下的system32文件夹中会看到kernel32.dll、user32.dll和gdi32.dll，windows的大多数API都包含在这些DLL中。kernel32.dll中的函数主要处理内存管理和进程调度；user32.dll中的函数主要控制用户界面；gdi32.dll中的函数则负责图形方面的操作。 一般的程序员都用过类似MessageBox的函数，其实它就包含在user32.dll这个动态链接库中。由此可见DLL对我们来说其实并不陌生。 (3)VC动态链接库的分类 Visual C++支持三种DLL，它们分别是Non-MFC DLL（非MFC动态库）、MFC Regular DLL（MFC规则DLL）、MFC Extension DLL（MFC扩展DLL）。 非MFC动态库不采用MFC类库结构，其导出函数为标准的C接口，能被非MFC或MFC编写的应用程序所调用；MFC规则DLL 包含一个继承自CWinApp的类，但其无消息循环；MFC扩展DLL采用MFC的动态链接版本创建，它只能被用MFC类库所编写的应用程序所调用。 由于本文篇幅较长，内容较多，势必需要先对阅读本文的有关事项进行说明，下面以问答形式给出。 问：本文主要讲解什么内容？ 答：本文详细介绍了DLL编程的方方面面，努力学完本文应可以对DLL有较全面的掌握，并能编写大多数DLL程序。 问：如何看本文？ 答：本文每一个主题的讲解都附带了源代码例程，可以随文下载（每个工程都经WINRAR压缩）。所有这些例程都由笔者编写并在VC++6.0中调试通过。
FORTRAN静态库动态库的生成
FORTRAN静态库、动态库的生成、维护与调用 闫昊明2006-9-10 一、FORTRAN静态库的生成与维护 FORTRAN 静态库是经过编译的代码块，它与主程序相对独立，可以被主程序调用，是FORTRAN工程类型之一. 静态库包含一系列子程序，但不包括主程序. 静态库一般具有LIB扩展名并包含目标代码，且静态库存放在它们特定的目录中. FORTRAN静态库在组织大型程序和在不同程序之间共享子程序等方面具有较大的优点，其重要性不言而喻. 当将静态库与主程序联系起来时，在主程序中调用静态库中的任何子程序将编译到相应的可执行程序. 应用静态库的时候，只有所需要的子程序才在编译过程中插入到可执行文件（.EXE）,这意味着这种可执行文件将比包含所有的子程序所生成的可执行文件小. 而且，不必担心哪些子程序是需要的，哪些是不需要的，编译器将替你做出选择. 同时，当更改静态库中的子程序时，相应的应用程序可以不做任何改变，而只需要对其进行重新的编译链接，即可获得新的结果，这无疑也是方便的. 目前，常用的FORTRAN静态库有很多种，WINDOWS操作系统下的Compaq Visual FORTRAN version 6.5（简称CVF65）自带的数学统计库IMSL就是一个非常全面的静态库，可以用来解决线性代数和统计学上的很多经典问题. 此外，在NCAR互联网站有很多有用的FORTRAN子程序（网址：https://www.wendangku.net/doc/ba1603897.html,/softlib/mathlib.html），其中包括地球物理科学问题、离散和快速Fourier变换、可分离的椭圆微分方程、插值、Legendre多项式、普通数学问题、本征值问题求解、线性方程求解、非线性方程求解、常微分方程求解、特殊函数、统计学等常用子程序集等. 这些FORTRAN子程序可以解决很多基础性的问题，因此有很高的利用价值. 在WINDOWS操作系统下，可以用两个命令分别生成静态库. 一个是用‘nmake’命令，它一般用来编译原来应用在UNIX环境下的FORTRAN子程序集，在编译过程中要读取makefile文件中的编译命令，类似于在UNIX下安装软件. 另一个是用‘lib’命令，它可以在WINDOWS环境下编译任何需要集成为静态库的子程序集. 编译静态库在DOS命令行环境下比较方便，以后的命令行都指在此环境下运行. 在编译静态库前，首先要安装CVF65，其次要完成要编译的FORTRAN子程序(*.f90). 对于FORTRAN子程序，最好用FORTRAN90的标准来完成，应该放弃FORTRAN77标准。FORTRAN90是FORTRAN语言从结构化走向面向对象化的重要一步，使FORTRAN语言更加接近C＋＋。在FORTRAN90标准中，对数组的操作既增强了功能又简化了使用，此外自由格式、MODULE、动态数组、指针等的应用大大丰富了FORTRAN语言，使得编程更加轻松。目前，FORTRAN95和FORTRAN2000标准也在应用，它们与FORTRAN90标准比较类似，主要的改进在并行运算方面，因此目前在单机上应用的主要还是FORTRAN90. 在DOS命令行环境下，进入到FORTRAN子程序所在的子目录，然后按下面两个步骤生成FORTRAN静态库. （1）键入“df *.f90 /c”，回车，可以看到CVF65编译器对所有的FORTRAN子程序（*.f90）进行编译，生成*.obj文件（注意，编译时，/c中的“c”必须小写）. （2）键入“lib *.obj /out:libname.lib”，回车，可以看到链接生成libname.lib静态库. 需要注意的是，每次加入新的子程序或对静态库中的子程序修改以后，都要按上述两个步骤重新进行编译链接. 生成静态库以后，可用“dumpbin /linkermember libname.lib”来查看静态库中可用的子程序名称. 也可执行“lib /list libname.lib”来查看静态库中的*.obj文件. 当然，也可以在CVF65集成环境下，生成静态库. 步骤如下：
VC++ MFC DLL动态链接库编写详解
VC++ MFC DLL动态链接库编写详解(2008-07-10 17:38:40) 标签：it分类：com技术然能用DLL实现的功能都可以用COM来替代，但DLL的优点确实不少，它更容易创建。本文将讨论如何利用VC MFC来创建不同类型的DLL，以及如何使用他们。 一、DLL的不同类型 使用VC++可以生成两种类型的DLL：MFC扩展DLL和常规DLL。常规DLL有可以分为动态连接和静态连接。Visual C++还可以生成WIN32 DLL，但不是这里讨论的主要对象。 1、MFC扩展DLL 每个DLL都有某种类型的接口：变量、指针、函数、客户程序访问的类。它们的作用是让客户程序使用DLL，MFC扩展DLL可以有C++的接口。也就是它可以导出C++类给客户端。导出的函数可以使用C++/MFC数据类型做参数或返回值，导出一个类时客户端能创建类对象或者派生这个类。同时，在DLL中也可以使用DLL和MFC。 Visual C++使用的MFC类库也是保存在一个DLL中，MFC扩展DLL动态连接到MFC代码库的DLL，客户程序也必须要动态连接到MFC代码库的DLL。（这里谈到的两个DLL，一个是我们自己编写的DLL，一个装MFC类库的DLL）现在MFC代码库的DLL也存在多个版本，客户程序和扩展DLL都必须使用相同版本的MFC代码DLL。所以为了让MFC扩展DLL能很好的工作，扩展DLL和客户程序都必须动态连接到MFC代码库DLL。而这个DLL必须在客户程序运行的计算机上。 2、常规DLL 使用MFC扩展DLL的一个问题就是DLL仅能和MFC客户程序一起工作，如果需要一个使用更广泛的DLL，最好采用常规DLL，因为它不受MFC的某些限制。常规DLL也有缺点：它不能和客户程序发送指针或MFC派生类和对象的引用。一句话就是常规DLL和客户程序的接口不能使用MFC，但在DLL和客户程序的内部还是可以使用MFC。 当在常规DLL的内部使用MFC代码库的DLL时，可以是动态连接/静态连接。如果是动态连接，也就是常规DLL需要的MFC代码没有构建到DLL中，这种情况有点和扩展DLL类似，在DLL运行的计算机上必须要MFC代码库的DLL。如果是静态连接，常规DLL里面已经包含了需要的MFC代码，这样DLL的体积将比较大，但它可以在没有MFC代码库DLL的计算机上正常运行。 二、建立DLL 利用Visual C++提供的向导功能可以很容易建立一个不完成任何实质任务的DLL，这里就不多讲了，主要的任务是如何给DLL添加功能，以及在客户程序中利用这个DLL 1、导出类 用向导建立好框架后，就可以添加需要导出类的.cpp .h文件到DLL中来，或者用向导创建C++ Herder File/C++ Source File。为了能导出这个类，在类声明的时候要加“_declspe c(dllexport)”,如：
编译生成动态库时,被关联的静态库会被编译到动态库里面
动态库调用静态库. 生成动态库: 需要的目标文件得用-fPIC选项生成. 而静态库所需的目标文件可以不用-fPIC选项. 一个应用程序调用动态库, 而这个动态库其中的函数调用某静态库时,如何生成应用程序呢? 例: /////// static.h void static_print(); ///////static.cpp #include
演练：创建和使用动态链接库 (C++)
Visual C++ 指导教程 演练：创建和使用动态链接库(C++) Visual Studio 2010 其他版本 0（共1）对本文的评价是有帮助评价此主题 我们将创建的第一种类型的库是动态链接库(DLL)。使用DLL 是一种重用代码的绝佳方式。您不必在自己创建的每个程序中重新实现同一例程，而只需对这些例程编写一次，然后从需要该功能的应用程序引用它们即可。 本演练涵盖以下内容： ?创建新的动态链接库(DLL) 项目。 ?向动态链接库添加类。 ?创建引用动态链接库的应用程序。 ?在控制台应用程序中使用类库的功能。 ?运行应用程序。 系统必备 本主题假定您具备C++ 语言的基础知识。如果您是刚开始学习C++，建议您参阅Herb Schildt 编写的“C++ Beginner's Guide”（《C++ 初学者指南》），该书可从 https://www.wendangku.net/doc/ba1603897.html,/fwlink/?LinkId=115303在线获得。 创建新的动态链接库(DLL) 项目 1.从“文件”菜单中，选择“新建”，然后选择“项目…”。 2.在“项目类型”窗格中，选择“Visual C++”下的“Win32”。 3.在“模板”窗格中，选择“Win32 控制台应用程序”。 4.为项目选择一个名称，如MathFuncsDll，并将其键入“名称”字段。为解决方案选择一个名 称，如DynamicLibrary，并将其键入“解决方案名称”字段。 5.单击“确定”启动Win32 应用程序向导。在“Win32 应用程序向导”对话框的“概述”页中， 单击“下一步”。
6.在“Win32 应用程序向导”中的“应用程序设置”页中，选择“应用程序类型”下的“DLL”（如果 可用），或者选择“控制台应用程序”（如果“DLL”不可用）。某些版本的Visual Studio 不支持通过使用向导创建DLL 项目。您可以稍后对此进行更改，以将项目编译为DLL。 7.在“Win32 应用程序向导”的“应用程序设置”页中，选择“附加选项”下的“空项目”。 8.单击“完成”创建项目。 向动态链接库添加类 1.若要为新类创建头文件，请从“项目”菜单中选择“添加新项…”。将显示“添加新项”对话框。 在“类别”窗格中，选择“Visual C++”下的“代码”。在“模板”窗格中选择“头文件(.h)”。为 头文件选择一个名称，如MathFuncsDll.h，并单击“添加”。将显示一个空白文件。 2.添加一个名为“MyMathFuncs”的简单类，以执行常见的算术运算，如加、减、乘和除。代 码应与以下内容类似： 复制 // MathFuncsDll.h namespace MathFuncs { class MyMathFuncs { public: // Returns a + b static __declspec(dllexport) double Add(double a, double b); // Returns a - b static __declspec(dllexport) double Subtract(double a, dou ble b); // Returns a * b static __declspec(dllexport) double Multiply(double a, dou ble b); // Returns a / b // Throws DivideByZeroException if b is 0 static __declspec(dllexport) double Divide(double a, doubl e b); }; } 3.请注意此代码方法声明中的__declspec(dllexport)修饰符。这些修饰符使DLL 能够导出 该方法以供其他应用程序使用。有关更多信息，请参见dllexport, dllimport。
C语言程序静态库和动态库的创建及其应用
C语言程序静态库和动态库的创建及其应用 在用c写程序时，很多时候需要存储一些简单的数据，如果为此而用mysql数据库就有些大才小用了，可以把这些数据以结构的形写入文件，然后再需要时读取文件，取出数据。 如下是定义函数的源文件和头文件： 源文件struct.c: #include "struct.h" //第一个参数是要写入的文件名，第二个参数是缓冲区，第三个参数是缓冲区大小，第四个参数是打开文件流的形态，返回TRUE表示写入成功，返回FALSE表示写入失败int writeStruct(const char *fileName,char *buffer,int bufferLen,char *mode){ int ret; FILE *fileID = NULL; fileID = fopen(fileName,mode); if (fileID == NULL){ perror("fopen"); goto writeEnd; } rewind(fileID); ret = fwrite(buffer,bufferLen,1,fileID); if (ret <= 0){ perror("fwrite"); goto writeEnd; } if (fileID != NULL){ fclose(fileID); fileID = NULL; } return TRUE;
writeEnd: if (fileID != NULL){ fclose(fileID); fileID = NULL; } return FALSE; } //第一个参数是要读取的文件名，第二个参数是缓冲区，第三个参数是缓冲区大小，第四个参数是打开文件流的形态，返回TRUE表示读取成功，返回FALSE表示读取失败int readStruct(const char *fileName,char *buffer,int bufferLen,char *mode){ int ret; FILE *fileID = NULL; fileID = fopen(fileName,mode); if (fileID == NULL){ perror("fopen"); goto readEnd; } rewind(fileID); memset(buffer,0,sizeof(buffer)); ret = fread(buffer,bufferLen,1,fileID); if (ret >= 0){ strcat(buffer,"\0"); }else{ perror("fread") ; goto readEnd; } if (fileID != NULL){ fclose(fileID); fileID = NULL; }
使用Automake生成Makefile及动态库和静态库的创建
使用Automake生成Makefile及动态库和静态库的创建使用Automake 创建和使用静态库 1. 目录结构如下： [c-sharp]view plaincopy 1.example 2.|——src 目录（存放源代码文件） 3. |——hello.c 4.|——lib 目录（存放用来生成库的文件） 5. |——test.c 用来生成静态库libhello.a 6.|——include 目录（存放程序中使用的头文件） 7. |——hello.h 2. 编写的各个目录下的源文件 [c-sharp]view plaincopy 1.hello.h 文件 2.extern void print(char *); 3.test.c 文件 4.#include
[c-sharp]view plaincopy 1.noinst_LIBRARIES=libhello.a 2.libhello_a_SOURCES=test.c 3.AUTOMAKE_OPTIONS=foreign 第一行noinst 表示生成的是静态库，不需要make install ，直接制定它的位置和名字就 可以使用。 第二行表示用来生成静态库的源文件。如果要把静态库生成到其他地方，可以在=后面 加上路径（建议用绝对路径，并将所要用到的静态库生成在同一个文件夹下，如lib）。 第三行AUTOMAKE_OPTIONS 是Automake 的选项。Automake 主要是帮助开发 GNU 软 件的人员来维护软件，所以在执行Automake 时，会检查目录下是否存在标准GNU 软件中 应具备的文件，例如 'NEWS'、'AUTHOR'、 'ChangeLog' 等文件。设置为foreign 时，Automake 会改用一般软件的标准来检查。如果不加这句的话，需要在autoconf之前，先执行touch NEWS README AUTHORS ChangeLog 来生成'NEWS'、'AUTHOR'、 'ChangeLog' 等文件4. 编写src/Makefile.am 文件 [c-sharp]view plaincopy 1.AUTOMAKE_OPTIONS=foreign 2.INCLUDES= -I../include 3.bin_PROGRAMS=hello 4.hello_SOURCES=hello.c 5.hello_LDADD=../lib/libhello.a 第二行指定头文件的位置，-I 是idirafter 的缩写。../include 指定头文件的位置，..是上 一级目录，也就是这里的example 目录。 第三行指定生成可执行文件名hello，在这里可执行文件生成在src 下，建议将可执行文 件生成到一个特定的文件夹下，让它和源代码分开，如/root/test 目录下。写法为： [c-sharp]view plaincopy 1.bin_PROGRAMS=/root/test/hello，后面的第四、五行也相对应地变为： 2._root_test_hello_SOURCES=hello.c 3._root_test_hello_LDADD=../lib/libhello.a
VC++ 2017 动态链接库的创建和使用总结
Visual studio c++ 2017 动态链接库的创建和使用总结 一动态链接库的创建两种方式： 1、只有从文件->新建->项目->Windows桌面-> Windows桌面向导->选择“动态链接 库(.dll)->生成解决方案，才会生成.dll和.lib文件。 （1）在头文件声明中(注意要在头文件变量和函数声明中，而不是在变量和函数的定义中声明)，不加extern “C”修饰，编译成DLL后，用depends.exe查看导出函数名。 可以看出，导出的函数名都被编译器篡改了。
（2）在头文件声明中，变量和函数名前加extern “C”修饰后，编译成DLL后，再用depends.exe查看导出函数名。 可以看出，用extern “C”修饰的函数名，编译后函数名保持不变。类及成员函数不能用extern “C”修饰，编译成DLL后，成员函数名发生了改变。 2、如果从文件->新建->项目->动态链接库(DLL)->生成解决方案，就只生成.dll,不生成.lib。
二动态链接库的调用两种方式： 1、显式调用 （1）使用显式调用的前提：创建的DLL，编译时不要篡改函数名称，定义函数名时，可用extern “C”修饰函数名，保证编译时，函数名不被篡改。否则GetProcAddress( )不能正确地获取dll中的函数名。 但是导出的类不能使用extern “C”修饰。 （2）使用显式调用的优点：不用动态链接库的.h和.lib文件，只要有.dll文件就可调用库函数，使用LoadLibrary（），在需要调用.dll中的库函数时，才动态加载到内存中，使用完毕后，可以用FreeLibrary()释放内存中的dll;使用GetProcAddress( )获取dll中的函数名。必须事先知道dll中的函数名和形式参数。 （3）使用显式调用缺点：调用每个函数时，都必须使用 GetProcAddress( )获取dll中的函数名，并转换成原来的函数，比较麻烦。而隐式调用DLL函数，由于使用了DLL的头文件.h，使用起来非常方便。 2、隐式调用 （1）隐式调用DLL函数缺点： 应用程序加载时，在内存中载入DLL动用库中的函数、变量、或类。使用完毕后，DLL 也不会从内存中释放。 .lib包含了库函数的入口，但不包含函数代码，应用程序调用时，才从dll中载入。（2）隐式调用DLL函数优点： 应用程序调用dll时，需要.lib和.h文件，在应用程序.exe文件夹debug或者release 中有DLL文件，即.h、.lib和.dll三个文件，在应用程序中直接使用DLL中的类和函数，可以不考虑编译DLL函数和变量名发生改变的问题。不需要像显式调用那样，函数需要 用 GetProcAddress( )一一获取。 隐式调用DLL中的变量、函数和类，有两种方法： （1）在主程序中包含DLL的头文件dll.h，在main( )前加上#pragma comment(lib,”dll.lib”)，没有分号，再在debug或release中复制DLL.dll。 （2）在主程序中包含DLL的头文件dll.h，在项目属性->链接器->添加依赖项中加上“dll.lib；“，再在debug或release中复制DLL.dll，即可。
(动态链接库)DLL编写与使用方法
DLL的创建与调用 1、DLL的概念 DLL(Dynamic Linkable Library)，动态链接库，可以向程序提供一些函数、变量或类。这些可以直接拿来使用。 静态链接库与动态链接库的区别： （1）静态链接库与动态链接库都是共享代码的方式。静态链接库把最后的指令都包含在最终生成的EXE 文件中了；动态链接库不必被包含在最终EXE文件中，EXE文件执行时可以“动态”地引用和卸载这个与EXE独立的DLL文件。 （2）静态链接库中不能再包含其他的动态链接库或者静态库，而在动态链接库中还可以再包含其他的动态或静态链接库。 动态链接库的分类：Visual C++支持三种DLL，它们分别是Non-MFC DLL（非MFC动态库）、MFC Regular DLL（MFC规则DLL）、MFC Extension DLL（MFC扩展DLL）。非MFC动态库不采用MFC 类库结构，其导出函数为标准的C接口，能被非MFC或MFC编写的应用程序所调用；MFC规则DLL 包含一个继承自CWinApp的类，但其无消息循环；MFC扩展DLL采用MFC的动态链接版本创建，它只能被用MFC类库所编写的应用程序所调用。 2、创建一个DLL 2.1 非MFC的DLL 2.1.1声明导出函数： extern “C” __declspec(dllexport) int add(int a, int b); 其中extern “C”为声明为C编译。由于C++编译器在编译的时候会造成其函数名的该变，在其他应用程序中导致函数不可调用，而C编译器则不会在编译后改变其函数名。这样如果用C编译的程序来调用该dll中的函数时，可能会造成找不到该函数。 __declspec（dllexport）表示该函数为DLL输出函数，即其他应用程序可以调用该函数 从dll中声明输出函数有两种方式： （1）另外一种方式是采用模块定义(.def) 文件声明，.def文件为链接器提供了有关被链接程序的导出、属性及其他方面的信息。 （2）用__declspec(dllexport)来声明函数 如果使用Visual C++来创建dll，对于同样用VC创建的exe来说，调用dll没有什么问题。而如果用其他工具来创建的exe来调用dll，就会出现问题。因为即使你不用C++编译器，Microsoft C编译器也会损害C函数。当用__stdcall将函数输出时，C编译器会将函数改为_func@1的形式。在这里需要在.def 文件中加入EXPORTS节来输出函数： EXPORTS func 这样，dll将用func函数名来输出函数。 另一种方式是用#pragma (linker, “/exports:func=_func@1”),告诉编译器输出函数func，这种方式没有前一种好。 如果通过VC++编写的DLL欲被其他语言编写的程序调用，应将函数的调用方式声明为__stdcall方式，WINAPI都采用这种方式，而C/C++ 缺省的调用方式却为__cdecl。__stdcall方式与__cdecl对函数名最终生成符号的方式不同。若采用C编译方式(在C++中需将函数声明为extern "C")，__stdcall调用约定在输出函数名前面加下划线，后面加“@”符号和参数的字节数，形如_functionname@number；
vs2012建立和引用lib、dll简明教程
Vs2012建立引用lib、dll简明教程 一、基本概念 Lib——静态链接库用到的指令都被直接包含在exe文件中，程序运行的时候不再需要其它的库文件。静态共享代码 DLL——把调用的函数所在dll和函数所在位置信息链接至程序中，程序运行的时候再从DLL中寻找相应函数代码，因此需要相应DLL文件的支持。动态引用和卸载 二、vs2012建立和引用lib 建立lib 1.创建静态项选择win32控制台应用程序->输入项目名称->选择静态链接库->取消 默认预编译头->完毕。 2.编写库创建cpp和h文件，并编写内容。 3.编译，创建完成，新lib在输出路径（debug）中。 引用lib 1.创建工程略 2.编写程序略 3.在项目->属性->配置属性->vc++目录->包含目标中附加之前工程的头文件的目录 4.在引用->通用属性->框架和引用->添加引用->勾选相应目录->确定（lib项目和该项目在同一路径下时）。 或者在vc++目录->库目录中添加新lib的路径，在链接器->输入->附加依赖项中添加新lib。 5.完成。在编写程序时要加上头文件包含。 三、vs2012建立和引用dll 建立dll 1. 创建动态项选择win32控制台应用程序->输入项目名称->选择动态链接库->取消默认预编译头->完毕。
2. 编写库创建cpp和h文件，并编写内容。在h文件中对函数的声明时注意，对于该dll输出接口的函数要用__declspec(dllexport)声明，如 extern “C”__declspec(dllexport) int Add(int &a,int &b); 加extern“C”是为了解决因C编译器与C++编译器对函数声明的编译情况不同（c语言不支持重载），而导致的调用错误。如果已知在c++环境下调用，可不必加。 3. 引用dll同时需要lib文件，再在项目中添加一个def文件。 4. 编译生成，新dll和lib在输出路径（debug）中。 此处的lib存放的是dll的函数入口位置，与单纯静态链接库 lib不同。 引用dll 1.创建工程略 2.编写程序略 3.在项目->属性->配置属性->vc++目录->包含目标中附加dll的头文件的目录 4.在引用->通用属性->框架和引用->添加引用->勾选相应目录->确定（dll项目和该项目在同一路径下时） 或者在vc++目录->库目录中添加新lib的路径，在链接器->输入->附加依赖项中添加新lib。 5.完成。在编写程序时要加上头文件包含。
[Linux]链接,静态库和动态库
[Linux]链接，静态库和动态库 Filename：[Linux]链接，静态库和动态库 Version：V1.0 Date：12/01/2009 Author：S.C.Leon
1.4库文件是如何产生的在linux下 静态库的后缀是.a，它的产生分两步 Step 1.由源文件编译生成一堆.o，每个.o里都包含这个编译单元的符号表 Step 2.ar命令将很多.o转换成.a，成文静态库 动态库的后缀是.so，它由gcc加特定参数编译产生。 具体方法参见后文实例。 1.5库文件是如何命名的，有没有什么规范 在linux下，库文件一般放在/usr/lib和/lib下， 静态库的名字一般为libxxxx.a，其中xxxx是该lib的名称 动态库的名字一般为libxxxx.so.major.minor，xxxx是该lib的名称，major是主版本号，minor是副版本号 1.6如何知道一个可执行程序依赖哪些库 ldd命令可以查看一个可执行程序依赖的共享库， 例如# ldd /bin/lnlibc.so.6 => /lib/libc.so.6 (0×40021000)/lib/ld-linux.so.2 => /lib/ld- linux.so.2 (0×40000000) 可以看到ln命令依赖于libc库和ld-linux库 1.7可执行程序在执行的时候如何定位共享库文件 当系统加载可执行代码时候，能够知道其所依赖的库的名字，但是还需要知道绝对路径 此时就需要系统动态载入器(dynamic linker/loader) 对于elf格式的可执行程序，是由ld-linux.so*来完成的，它先后搜索elf文件的DT_RPATH段—环境变量LD_LIBRARY_PATH—/etc/ld.so.cache文件列表— /lib/,/usr/lib目录找到库文件后将其载入内存 如：export LD_LIBRARY_PATH=’pwd’ 将当前文件目录添加为共享目录 1.8在新安装一个库之后如何让系统能够找到他 如果安装在/lib或者/usr/lib下，那么ld默认能够找到，无需其他操作。
dll(动态链接库)的创建和使用
dll的创建和使用使用C++语言创建dll并使用该dll的演示、说明
Dll的创建和使用 第一部分创建C风格的dll (4) 步骤1：创建dll工程 (4) 步骤2：文件改名 (5) 步骤3：拷贝文件内容 (6) 步骤4：从工程中删掉文件main.cpp,main.h (7) 步骤5：继续修改文件mydll.h和mydll.cpp (7) 步骤6：编译并生成dll文件 (8) 第二部分以间接调用的方式使用.dll (10) 步骤1：新建一个控制台工程(UseDll.cbp). (10) 步骤2：修改main.cpp。 (11) 步骤3：编译，生成UseDll.exe (12) 步骤4：拷贝mydll.dll到UseDll.exe所在目录 (13) 步骤5：执行UseDll.exe,输出： (13) 间接调用Dll的好处 (14) 第三部分以直接调用的方式使用.dll (15) 步骤1：改写main.cpp (15) 步骤2：添加mydll.dll的静态导出库到UseDll工程中 (16) 步骤3：编译并执行，输出 (17) 直接调用的好处 (18) Dll的优势 (18) 调用约定的说明 (18) 第四部分创建C++风格的dll（本地方法） (19) 步骤1：在mydll.h中新增导出的类 (19) 步骤2：在mydll.cpp中实现Cat类 (19) 步骤3：编译MyDll，生成mydll.dll，mydll.a (21) 第五部分使用本地风格的C++ DLL (22) 步骤1：修改UseDll中的main.cpp (22) 步骤2：将mydll.a添加到UseDll工程的BuildOptions中 (23) 步骤3：编译UseDll工程，生成UseDll.exe (23) 步骤4：将MyDll.dll拷贝到UseDll.exe目录下 (23) 步骤5：执行UseDll.exe，输出 (23) 本地风格的不足 (24) 第六部分创建推荐风格的C++ DLL (26) 步骤1：修改mydll.h，创建Cat的接口类ICat (26) 步骤2：新建类Cat (27) 步骤3：实现createCat函数 (29) 步骤4：编译，生成mydll.dll (31) 第七部分使用推荐风格的C++ DLL (32) 步骤1：修改UseDll中的main.cpp (32)
- VS2013创建dll动态链接库文件心得
- 五：动态链接库的建立与调用
- 操作系统实验一_动态链接库的建立与调用
- C C++动态链接库的创建与调用
- vs2012建立和引用lib、dll简明教程
- C和C中动态链接库的创建和调用
- 静态链接库LIB和动态链接库DLL的区别
- 动态链接库的创建和调用
- 演练：创建和使用动态链接库 (C++)
- 在VS2017中创建和使用动态链接库DLL
- C中如何调用动态链接库DLL
- VS2010 动态库开发
- 利用FORTRAN建立动态链接库的步骤如下
- (动态链接库)DLL编写与使用方法
- 动态链接库技术及其应用实例
- VC++动态链接库(DLL)编程深入浅出(全)
- 演练：创建和使用动态链接库
- VC++ MFC DLL动态链接库编写详解
- C++ 动态库创建与调用
- Linux静态链接库动态链接库的创建和使用及区别