linux编写动态库

‘壹’ 如何生成linux下的动态库和静态库

静态库 静态库的后缀是.a，它的产生分两步 Step 1.由源文件编译生成一堆.o，每个.o里都包含这个编译单元的符号表Step 2.ar命令将很多.o转换成.a，成为静态库动态库的后缀是.so，它由gcc加特定参数编译产生。具体方法参见后文实例。123123 在 GNU...

‘贰’ linux 编译动态库 automake 怎样生成.ver文件

Linux下的动态库以.so为后缀，我也是初次在Linux下使用动态库，写一点入门步骤，以便以后能方便使用。
第一步：编写Linux程序库
文件1.动态库接口文件
//动态库接口文件getmaxlen.h
#ifndef _GETMAXLEN_H_
#define _GETMAXLEN_H_
int getMaxLen(int *sel,int N);
#endif
文件2.动态库程序实现文件
//动态库程序实现文件getmaxlen.c
#include "getmaxlen.h"
int getMaxLen(int *sel,int N)
{
int n1=1,n2=1;
for(int i=1;i<N;i++)
{
if(sel[i]>sel[i-1])
{
n2 ++;
if(n2 > n1)
{
n1 = n2;
}
}
else
{
n2 = 1;
}
}
return n1;
}
第二步：编译生成动态库
gcc getmaxlen.c –fPIC –shared –o libtest.so
由以上命令生成动态库libtest.so，为了不需要动态加载动态库，在命令时需以lib开头以.so为后缀。
–fPIC：表示编译为位置独立的代码，不用此选项的话编译后的代码是位置相关的所以动态载入时是通过代码拷贝的方式来满足不同进程的需要，而不能达到真正代码段共享的目的。
–shared：指明编译成动态库。
第三步：使用动态库
1. 编译时使用动态库
文件1.动态库使用文件test.c
//使用动态库libtest.so,该文件名为test.c
#include "getmaxlen.h"
int main()
{
int Sel[] = {2,3,6,5,3,2,1,2,3,4,5,6,7,6,5};
int m;
m = getMaxLen(Sel,15);
printf("%d",m);
return 0;
}
编译命令：
gcc test.c –L . –l test –o test
–L：指明动态库所在的目录
-l：指明动态库的名称，该名称是处在头lib和后缀.so中的名称，如上动态库libtest.so的l参数为-l test。
测试：
ldd test
ldd 测试可执行文件所使用的动态库
2. 动态加载方式使用动态库
文件内容：
//动态库的动态加载使用
int main()
{
void *handle = NULL;
int (*getMaxLen)(int *sel,int N);
int sel[] = {1,2,5,4,5,8,6,5,9,5,4,5,4,1};
handle = dlopen("./libtest.so",RTLD_LAZY);
if(handle == NULL)
{
printf("dll loading error.\n");
return 0;
}
getMaxLen = (int(*)(int *,int))dlsym(handle,"getMaxLen");
if(dlerror()!=NULL)
{
printf("fun load error.\n");
return 0;
}
printf("%d\n",getMaxLen(sel,15));
}
编译命令：
gcc –ldl test1.c –o test
gcc -o test test.c ./libmytools.so

‘叁’ Linux中如何创建静态库和动态库

静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。 动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在。 程序1: hello.h #ifndef HELLO_H #define HELLO_H void hello(const char *name); #endif //HELLO_H 程序2: hello.c #include void hello(const char *name) { printf("Hello %s!\n", name); } 程序3: main.c #include "hello.h" int main() { hello("everyone"); return 0; } 无论动态库还是静态库都需要用到.o文件来生成，先编译生成.o文件。 # gcc -c hello.c 1：创建静态库 静态库文件名的命名规范是以lib为前缀，紧接着跟静态库名，扩展名为.a。例如：我们将创建的静态库名为myhello，则静态库文件名就是libmyhello.a。 # ar cr libmyhello.a hello.o 使用静态库：只需要在你的源程序中加入包含你所需要使用到的函数的声明(即包含头文件)，然后在gcc生成目标文件时候指明静态库就OK了(除非你包含的头文件在/usr/include，库文件在标准库/usr/lib,/lib下，否则你得显示指明他们的路径) # gcc -o hello main.c -L. -lmyhello # ./hello Hello everyone! 删除静态库文件运行./hello，程序正常运行，说明静态库公用函数已经链接到目标文件。 2： 利用.o文件创建动态库 动态库文件扩展名为.so。 # gcc -shared -fPCI -o libmyhello.so hello.o 动态库的使用与静态库使用方式一样 # gcc -o hello main.c -L. -lmyhello # ./hello ./hello: error while loading shared libraries: libmyhello.so: cannot open shared object file: No such file or directory 哦！出错了。快看看错误提示，原来是找不到动态库文件libmyhello.so。程序在运行时，会在/usr/lib和/lib等目录中查找需要的动态库文件。若找到，则载入动态库，否则将提示类似上述错误而终止程序运行。

‘肆’ 如何在linux下用matlab生成动态链接库

首先如何制作Linux下的so 文件

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

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

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

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

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

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

步骤：

首先建立一个函数文件fun.cpp 以及头文件 fun.h

[cpp]view plain

更改/etc/ld.so.conf，添加我们的库目录，然后执行ldconf

需要root权限

（3）加入/user/lib 或者/usr/lib64看你的机器位数,貌似拷贝的方法最凑效了，其他方法有时候行不通

‘伍’ Linux下的静态库和动态库

静态库

可以把它想象成是一些代码的集合，在可执行程序运行前就已经加到了代码中，成为了执行程序的一部分，一般是以.a为后缀的文件名，Windows下后缀为.lib。静态库的命名也分为三部分，1、前缀：lib，2、库的名称：随意，如lisi，3、后缀：.a。

静态库优缺点

上面简单介绍了静态库，那它自然也会有优缺点，这里来介绍下它的优缺点。

优点：1、在最后，函数库是被打包到应用程序中的，实现函数本地化、寻址方便、高效。2、程序在运行的时候，与函数库没有关系，移植性更强。

缺点：1、消耗资源较大，每个进程在使用静态库的时候，都要复制一份才可以，这也就造成了内存的消耗。2、在程序更新、部署、发布的时候，使用静态库相对麻烦，如果一个静态库更新了，那它的应用程序都需要重新编译，再发送给用户，有的时候可能只是一个小的改动，但对于用户来说，会导致整个程序重新下载。

动态库

在程序编译时不会被连接到目标代码中，在后期运行时才会载入，不同的应用程序如果调用相同的库，内存中只有一份共享库的拷贝，也就避免了空间的浪费问题。一般以.so作为文件后缀名，也分为三部分：1、前缀：lib，2、库名称：自定义，3、后缀：.so

动态库优缺点

优点：1、节省内存2、部署、升级相对方便，只需要更换动态库，再重新启动服务即可。

缺点：1、加载速度比静态库慢2、移植性较差，需要把所有用到的动态库进行移植。

‘陆’ 如何使用lame源代码在编译生成linux环境下的动态库

动态库的生成
1>首先生成目标文件，但是此时要加编译器选项-fpic和链接器选项-shared，

gcc -fpic -c add.c

gcc -fpic -c sub.c

生成中间文件add.o和sub.o

2>其次生成动态库

gcc -shared –o libtiger.so add.o sub.o

生成动态库libtiger.so,libtiger.so就是我们生成的目标动态库。我们以后使用动态库和main.c程序生成可执行程序

说明：

以上两部也可以合成一步搞定:

gcc -fpic -shared add.c sub.c -o libtiger.so

2.使用动态链接库

在编译程序时，使用动态链接库和静态库是一致的，使用”-l库名”的方式，在生成可执行文件的时候会链接库文件。

1>使用命令：

gcc -o main main.c -L ./ -ltiger

2>-L指定动态链接库的路劲，-ldtiger链接库函数tiger。-ltiger是动态库的调用规则。Linux系统下的动态库命名方式是lib*.so,而在链接时表示位-l*,*是自己命名的库名。

3>但是程序会提示如下错误

error while loading shared libraries: libtiger.so: cannot open shared object file: No such file or direct

这是因为程序运行时没有找到动态链接库造成的。程序编译时链接动态库和运行时使用动态链接库的概念是不同的，在运行时，程序链接的动态链接库需要在系统目录下才行。

4>使用以下方法可以解决此问题

a. 在linux下最方便的解决方案是拷贝libtiger.so到绝对目录 /lib 下(但是,要是超级用户才可以，因此要使用sudo哦，亲)。就可以生成可执行程序了

b.第二种方法是：将动态链接库的目录放到程序搜索路径中，可以将库的路径加到环境变量LD_LIBRARY_PATH中实现：

export LD_LIBRARY_PATH=`pwd`:$LD_LIBRARY_PATH

‘柒’ Linux下怎么用C++实现动态链接库

写个
C程序
，makefile
里面发布成一个
动态库
文件，比如.so结尾的文件
另外的程序如果要用这个so里面的方法,编译时候在makefile里面增加对lib的引用,比如
THE_INCLUDE
=
-I$(WORK_HOME)/include
-I$(CRM_HOME)/include
THE_LIBPATH
=
-L$(WORK_HOME)/lib
-L$(CRM_HOME)/lib
THE_LIB
=
-lConfigFile
-lbase
-locci10
-lfile
-lwsc

‘捌’ 如何用qt在linux中编写并使用动态链接库

先写好实现动态链接库的libmy.cpp文件和libmy.h文件，如下：

// libmy.cpp

#include"libmy.h"

#include<iostream>

using namespace std;
MyLib::MyLib()
{
}

MyLib::~MyLib()
{
}

void MyLib::hello()
{
cout << "hello world~!" << endl;
}

// libmy.h文件

#ifndef LIBMY_H
#define LIBMY_H
class MyLib

{
public:
MyLib();
~MyLib();
void hello();
};
#endif /*LIBMY_H*/

然后写好pro文件，如下：

TEMPLATE = lib
TARGET =DllTest

HEADERS += libmy.h
SOURCES += libmy.cpp

保存关闭，文件名命名为MyDll.pro
在Shell里执行qmake MyDll.pro,在没有错误的情况下，然后执行make ，可以看到生成了几个后缀名为so的文件，如下图：