gcc编译的链接动态库

❶ AIX下gcc编译器怎么使用动态连接库

链接静态库其实从某种意义上来说也是一种粘贴复制，只不过它操作的对象是目标代码而不是源码而已。因为静态库被链接后库就直接嵌入可执行文件中了，这样就带来了两个问题。
首先就是系统空间被浪费了。这是显而易见的，想象一下，如果多个程序链接了同一个库，则每一个生成的可执行文件就都会有一个库的副本，必然会浪费系统空间。
再者，人非圣贤，即使是精心调试的库，也难免会有错。一旦发现了库中有bug，挽救起来就比较麻烦了。必须一一把链接该库的程序找出来，然后重新编译。
而动态库的出现正弥补了静态库的以上弊端。因为动态库是在程序运行时被链接的，所以磁盘上只须保留一份副本，因此节约了磁盘空间。如果发现了bug或要升级也很简单，只要用新的库把原来的替换掉就行了。

❷ 如何用gcc编译生成动态链接库*.so文件

生成动态链接库的命令行为：
gcc -fPIC -shared -o libstr.so
当将main.c和动态链接库进行连接生成可执行文件 的命令如下：
gcc main.c -L./ -lstr -o main或者gcc -o main main.c -L./ -lstr
测试是否动态链接，如果列出libstr.so, 那么应该是连接正常了ldd main注：1）-L.：表示连接的库在当前的目录中。

❸ linux中编译时怎么连接动态库

Linux系统中静态库是.a文件，编译链接.a文件只需要加上.a文件的完整路径就可以了，比如：
gcc -o hello hello.c /usr/lib/libm.a
Linux系统的动态库是.so文件，编译链接动态库需要用-L参数指定动态库的搜索路径，还要用-l（这个是小写的L）指定动态库的名字，比如：
gcc -o hello hello.c -L/usr/openssl/lib -lcrypto

❹ 关于gcc编译选项选取动态库不同版本的问题

不同版本的动态库是为了升级方便，旧的程序需要与旧的库链接，新的程序与新的．

一般的做法是把libabc.so连接(symbolic link, ln -s libabc.so.N libabc.so)到最新的版本，这样以后的新程序，在用gcc -labc的时候，都会链接到新的版本．旧的已经链接好的程序并不会产生不兼容的问题，因为旧程序在过去已经链接过了（动态库链接的信息可以用ldd来查看: ldd /bin/ls）．

symbolic link, ln是推荐的维护版本的办法，不建议更改文件名．

如果你要有一个方便的办法链接旧的版本, 建一个旧的版本的symbolic link就可以了,libabc11.so
ln -s libabc.so.11 libabc11.so
gcc -labc11...

❺ GCC中静态连接和动态连接的区别

gcc中静态连接和动态链接的方法：

1：GCC的静态连接，直接把静态库的名字放在gcc后面

例如：gcc-otesttest.cstaticlib.a

2：GCC的动态连接，使用-l指定库，-L指定库的路径，注意动态库名必须是lib开头，后缀名为.so

例如：gcc-otesttest.c-lpthread-L/usr/lib/

3：静态库也可以采用动态库的连接方法，如果目录中同时存在2种库，gcc会优先选择动态库。如果一条gcc链接指令中既要链接动态库又要链接静态库，可以用-Wl,-dn和－Wl,-dy参数选项来切换。

静态连接和动态链接的主要区别：

1：静态连接的时候，静态库的所有执行代码被直接编译到目标程序中。而动态连接的时候，仅仅把动态库的函数和变量的符号名，地址偏移量等导入到目标程序。只有在目标程序运行的时候才把动态库的执行代码加载到内存中。

2：动态链接的项目容易管理，把不同模块封装成不同的动态库，如果模块功能修改，一般只需要重新生成该动态库，不用重新编译其他模块和目标程序。而静态链接的程序修改任何一个地方都必须重新编译整个程序

3：静态链接生成的目标程序体积比动态链接的大，但是加载速度更快，发布更容易，不需要检查发布机器上是否有该动态库或者动态库版本是否符合要求。

4：如果多个程序使用一个动态库，则该库的执行代码只会在内存中加载一次。而静态库是多次加载（事实上静态库连接完就没用了，等于目标程序的一部分）。

5：从调试的角度来说，静态连接的程序调试方法和独立程序没有任何区别，而动态库的调试相对要复杂一些，因为库里面的符号地址都是相对地址。

❻ 如何使用GCC生成动态库和静态库

下面以工程libtest为例说明gcc创建和使用静态库、动态库的过程，libtest目录结构和内容如图1所示，其中三个文件hello.h，hello.c和main.c的内容如下。

libtest/include/hello.h

#ifdef _HELLO_H_
#define _HELLO_H_
void hello();
#endif
libtest/lib/hello.c
#include "hello.h"
#include <stdio.h>
void hello()
{
printf("hello world!\n");
}
libtest/src/main.c
#include "hello.h"
int main()
{
hello();
}

静态库过程如下：
（1） 进入libtest/lib目录，执行命令：
gcc -c -I../include hello.c
该命令生成目标文件hello.o，注意：参数-I添加头文件搜索目录，这里因为hello.c中有#include “hello.h”，hello.h在libtest/include目录中，这里需要指定该目录通知gcc，否则出现错误提示“找不到头文件hello.h”。
这一步将在libtest/lib目录中生成一个hello.o文件。
（2） 在libtest/lib目录，执行命令：
ar rc libhello.ahello.o
该命令将hello.o添加到静态库文件libhello.a，ar命令就是用来创建、修改库的，也可以从库中提出单个模块，参数r表示在库中插入或者替换模块，c表示创建一个库
这一步将在libtest/lib目录中生成一个libhello.a文件。
（3） 进入libtest/src目录，执行命令：
gcc main.c-I../include -L../lib -lhello -o main
该命令将编译main.c并链接静态库文件libhello.a生成可执行文件main，注意：参数-L添加库文件搜索目录，因为libhello.a在libtest/lib目录中，这里需要指定该目录通知gcc，参数-l指定链接的库文件名称，名称不用写全名libhello.a，只用写hello即可。
这一步将在libtest/src目录中生成可执行文件main。

动态库过程如下：
（1） 进入libtest/lib目录，执行命令：
gcc hello.c-I../include -fPIC -shared -o libhello.so
这一步将在当前目录生成动态库文件libhello.so，参数-fPIC -shared固定格式，不用纠结他们什么意思。
（2） 进入libtest/src目录，执行命令：
gcc main.c-I../include -L../lib -lhello -o main
此时在当前目录中已经生成了可执行文件main，执行./main时却提示错误：
./main: error while loading shared libraries: libhello.so: cannotopen shared object file: No such file or directory
也就是找不到动态库文件libhello.so，在网上找了答案说如果遇到这样的问题需要设置环境变量LD_LIBRARY_PATH，如下：
export LD_LIBRARY_PATH=”../lib”
gcc main.c -I../include -L../lib -lhello -o main
然后再执行./main就没有错误了。
【补充】
环境变量LD_LIBRARY_PATH指示动态连接器可以装载动态库的路径，在链接动态库文件前设置该变量为库文件所在路径，注意：用export LD_LIBRARY_PATH=”…”方式只是临时生效的，如果要永久有效可以写入~/.bashrc文件中，跟修改PATH类似，exportLD_LIBRARY_PATH=$LD_LIBRARY_PATH:”…”。
当然如果有root权限的话，也可以修改/etc/ld.so.conf文件，将要添加的动态库搜索路径写入该文件中，然后调用/sbin/ldconfig来达到同样的目的。

❼ 如何用gcc编译动态库

今天要用到静态库和动态库，于是写了几个例子来巩固一下基础。
hello1.c ————————————————————
#include <stdio.h>
void print1(int i) { int j; for(j=0;j<i;j++) { printf("%d * %d = %d\n",j,j,j*j); } }
hello2.c _________________________________________________
#include <stdio.h>
void print2(char *arr) { char c; int i=0; while((c=arr[i++])!='\0') { printf("%d****%c\n",i,c); } }
hello.c ____________________________________________________
void print1(int); void print2(char *);
int main(int argc,char **argv) { int i=100; char *arr="THIS IS LAYMU'S HOME!"; print1(i); print2(arr);
return 0; }

可以看到hello.c要用到hello1.c中的print1函数和hello2.c中的print2函数。所以可以把这两个函数组合为库，以供更多的程序作为组件来调用。

方法一：将hello1.c和hello2.c编译成静态链接库.a
[root@localhost main5]#gcc -c hello1.c hello2.c
//将hello1.c和hello2.c分别编译为hello1.o和hello2.o，其中-c选项意为只编译不链接。
[root@localhost main5]#ar -r libhello.a hello1.o hello2.o
//将hello1.o和hello2.o组合为libhello.a这个静态链接库
[root@localhost main5]#cp libhello.a /usr/lib
//将libhello.a拷贝到/usr/lib目录下，作为一个系统共享的静态链接库
[root@localhost main5]#gcc -o hello hello.c -lhello
//将hello.c编译为可执行程序hello，这个过程用到了-lhello选项，这个选项告诉gcc编译器到/usr/lib目录下去找libhello.a的静态链接库
以上的过程类似于windows下的lib静态链接库的编译及调用过程。
方法二：将hello1.o和hello2.o组合成动态链接库.so
[root@localhost main5]#gcc -c -fpic hello1.c hello2.c
//将hello1.c和hello2.c编译成hello1.o和hello2.o，-c意为只编译不链接，-fpic意为位置独立代码，指示编译程序生成的代码要适合共享库的内容这样的代码能够根据载入内存的位置计算内部地址。
[root@localhost main5]#gcc -shared hello1.o hello2.o -o hello.so
//将hello1.o和hello2.o组合为shared object，即动态链接库
[root@localhost main5]#cp hello.so /usr/lib
//将hello.so拷贝到/usr/lib目录下
[root@localhost main5]#gcc -o hello hello.c hello.so
//将hello.c编译链接为hello的可执行程序，这个过程用到了动态链接库hello.so

在这里要废话几句，其实一切的二进制信息都有其运作的机制，只要弄清楚了它的机制，并能够实现之，则任何此时此刻无法想象之事都将成为现实。当然，这两者之间的巨大鸿沟需要顶级的设计思想和顶级的代码来跨越。

❽ acc和gcc编译动态库的区别

编译动态库时，acc使用-b开关，gcc使用-share开关，acc使用-AA开关编译标准c++代码，-mt加入多线程链接，gcc使用-pthread开关，acc使用+Markered开关编译出cpp文件所需的头文件，并以xxx.d文件形式存放，acc和gcc的共同的开关有-I加入头文件目录，-l开关加入依赖的动态库链接，-L开关加入动态库搜寻的路径，-o开关输出目标文件，-g开关加入调试信息，-w开关加入警告级别。在64位的机器上，acc使用+DD32开关编译32位程序，gcc使用-milp32编译32位程序，此外，在64位机器上，默认是编译32位的程序。

❾ Linux 如何使用gcc生成静态库和动态库

Linux库有动态与静态两种，动态通常用.so为后缀，静态用.a为后缀。例如：libhello.so libhello.a 为了在同一系统中使用不同版本的库，可以在库文件名后加上版本号为后缀,例如： libhello.so.1.0,由于程序连接默认以.so为文件后缀名。所以为了使用这些库，通常使用建立符号连接的方式。 ln -s libhello.so.1.0 libhello.so.1 ln -s libhello.so.1 libhello.so 动态库和静态库的区别： 当要使用静态的程序库时，连接器会找出程序所需的函数，然后将它们拷贝到执行文件，由于这种拷贝是完整的，所以一旦连接成功，静态程序库也就不再需要了。然而，对动态库而言，就不是这样。动态库会在执行程序内留下一个标记‘指明当程序执行时，首先必须载入这个库。由于动态库节省空间，linux下进行连接的缺省操作是首先连接动态库，也就是说，如果同时存在静态和动态库，不特别指定的话，将与动态库相连接。 两种库的编译产生方法： 第一步要把源代码编绎成目标代码。以下面的代码hello.c为例，生成hello库： /* hello.c */ #include void sayhello() { printf("hello,world\n"); } 用gcc编绎该文件，在编绎时可以使用任何全法的编绎参数，例如-g加入调试代码等： gcc -c hello.c -o hello.o 1.连接成静态库 连接成静态库使用ar命令，其实ar是archive的意思 $ar cqs libhello.a hello.o 2.连接成动态库 生成动态库用gcc来完成，由于可能存在多个版本，因此通常指定版本号： $gcc -shared -Wl,-soname,libhello.so.1 -o libhello.so.1.0 hello.o 另外再建立两个符号连接： $ln -s libhello.so.1.0 libhello.so.1 $ln -s libhello.so.1 libhello.so 这样一个libhello的动态连接库就生成了。最重要的是传gcc -shared 参数使其生成是动态库而不是普通执行程序。 -Wl 表示后面的参数也就是-soname,libhello.so.1直接传给连接器ld进行处理。实际上，每一个库都有一个soname，当连接器发现它正在查找的程序库中有这样一个名称，连接器便会将soname嵌入连结中的二进制文件内，而不是它正在运行的实际文件名，在程序执行期间，程序会查找拥有 soname名字的文件，%B

❿ LLINUX GCC 编译C使用自定义动态链接库.so的问题

1. 可以参考如下关于库文件的文章:http://numanal.com/?p=129
2. 在编译文件时最好用-L指明自定义库的存在目录, 利用如下任一语句(.so文件与.c文件在同一目录):
gcc test.c -o test2 -L./verify.so
gcc test.c -o test2 -L.
3. 你这里在的问题应该与编译器的某些兼容性有关, 在实际编写程序的时候最好按gcc的语法规范走, 避免不必要的错误.