编译动态库依赖动态库

❶ linux编译一个动态库，将所依赖的其他库的头文件包含了进来，但没指定其他静态库的路径和名称

编译能过。因为头文件的声明，表示在某个地方这些变量被定义了。既然被定义了，当然编译能过。但是如果没有那些库，链接是不能过的。

❷ A动态库使用了B静态库，而B静态库依赖于C动态库。 当编译A动态库时，报error LNK2019: 无法解析的外部符号

你好，请详细说明你的问题！
在你提供的信息中，我只能猜测是你在gcc是你的静态库B的位置放在了A的前面，所以导致的问题。

例如：
A依赖于B的函数f
gcc test.c B A C -o test
则，由于你的A使用了B的f，gcc在链接时，发现test.c没有用到B库的f，所以不会将f链接到test，而C已经没有机会链接到B的f（因为gcc按照顺序链接输入文件）。
结果导致A所需要的f找不到，就包无法解析外部符号错误了。

❸ 我在一个机器上编了个动态库，在另一个机器上编译了一个引用这个动态库的可执行程序，能调用不

什么语言？C++还是C#？Native还是managed？

一般是没有问题的，只要保证：
1、你这个动态库没有依赖其他动态库（包括系统的、MFC的、CRT的、VC的、或者.NET Framework的），或者依赖的其他动态库在另一台机器上也都有；
2、而且不存在32位和64位的兼容问题（即动态库以及可执行程序都是32位的或者都是64位的，而且操作系统也不存在这个兼容性的差异）；
3、可执行程序连接动态库使用的LIB文件和动态库是匹配的（如果是native的）

____________________
补充：

哦~~~ Linux我是门外汉了，那就看看其他朋友有没有Linux大拿帮忙回答一下吧……

❹ 如何编译动态库，该动态库需要链接另外一个动态库

看你的makefile, 猜测是没有指定动态库头文件的路径. -I编译参数来指定

❺ 求助，依赖的动态库包含静态库，编译报错说找

动态链接库和静态链接库一般是编译集成一系列的接口（函数）
在程序源代码编译完成后通过编译器编译并通过链接器与这些库进行链接
动态链接库与静态链接库的区别在于链接器在进行链接时静态库会被直接编译进程序里
而动态链接库并不会，我们这里将这些链接库称作依赖（动态库和静态库）
程序的运行需要这些依赖，程序在静态链接后该程序本身便已包含该依赖
而动态链接后的程序本身本不包含该依赖，这些依赖需要执行者自行安装进操作系统（动态库、运行时库）
程序运行时会动态地加载这些库

linux上动态库一般的后缀后为.so
静态库一般的后缀为.a
由于静态链接会直接将库编译进程序里所以静态编译后的程序相较于动态链接所要大
这就是因为静态链接会将链接库编译进程序里的原因，所以占用就要大了
出于这种原因，静态库不易于维护与更新，如果链接库中有实现有bug等需要更新则需要更新整个程序，因为静态库被编译进程序中了
但动态库就没有这种情况了，因为动态库是程序运行时动态加载的，所以我们只需要更新动态库而不需要更新所有依赖该库的程序（软件）

另一方面，很多程序的开发都会使用到相同的链接库，也就是很多程序（软件）会有相同的依赖
如果将这些依赖全部静态编译的话将会造成存储资源占用过多而造成资源浪费
而使用动态库的方式这些程序（软件）则可以共享一个链接库，而不需要每个程序都带一个链接库，这样就大大地减少了存储资源占用空间

❻ gcc编译多重依赖动态库，这样怎么会出问题

这只能说明一个问题，你依赖的库本身有问题，没有把它的依赖都加进去，也就是你例子中的①libb.so依赖liba.so;，你应该在生成libb.so的时候，把对liba.so的依赖加进去，这样应该就没有问题了。

❼ 如何将第三方类库编译自己的动态库文件中

随着动态库的流行，静态库越来越少了（关于动态库和静态库的介绍请点击），但是不排除项目中有些依赖的第三方还是使用的静态库。

那么这种情况下就可以考虑，将第三方静态库做一个二次封装。一来和业务代码进行隔离，方便以后第三方库的升级，二来将静态库封装进动态库里便于管理和利用动态库的优势。一般情况下，用动态库封装静态库很简单，就是将静态库直接拖进动态库的工程里，直接编译即可。但是有一种情况下这么做是不行的，需要暴露静态库的头文件，也就是虽然静态库放在动态库里面了，但是静态库的头文件还要提供给上层应用调用。

❽ g++ 编译命令中依赖的动态库如果还依赖别的库，命令怎么设置

第一步，我先从简单的调用出发，定义了一个简单的函数，该函数仅仅实现一个整数加法求和：

LIBEXPORT_API int mySum(int a,int b){ return a+b;}
C# 导入定义：

public class RefComm
{
[DllImport("LibEncrypt.dll",
EntryPoint=" mySum ",
CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]
public static extern int mySum (int a,int b);
}
在C#中调用测试：

int iSum = RefComm.mySum(,);

运行查看结果iSum为5，调用正确。第一步试验完成，说明在C#中能够调用自定义的动态链接库函数。

第二步，我定义了字符串操作的函数（简单起见，还是采用前面的函数名），返回结果为字符串：

LIBEXPORT_API char *mySum(char *a,char *b){sprintf(b,"%s",a); return a;}
C# 导入定义：

public class RefComm
{
[DllImport("LibEncrypt.dll",
EntryPoint=" mySum ",
CharSet=CharSet.Auto,
CallingConvention=CallingConvention.StdCall)]
public static extern string mySum (string a, string b);
}
在C#中调用测试：

string strDest="";
string strTmp= RefComm.mySum("45", strDest);

运行查看结果 strTmp 为"45"，但是strDest为空。我修改动态链接库实现，返回结果为串b：

LIBEXPORT_API char *mySum(char *a,char *b){sprintf(b,"%s",a) return b;}
修改 C# 导入定义，将串b修改为ref方式：

public class RefComm
{
[DllImport("LibEncrypt.dll",
EntryPoint=" mySum ",
CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]
public static extern string mySum (string a, ref string b);
}
在C#中再调用测试：

string strDest="";
string strTmp= RefComm.mySum("45", ref strDest);
运行查看结果 strTmp 和 strDest 均不对，含不可见字符。再修改 C# 导入定义，将CharSet从Auto修改为Ansi：

public class RefComm
{
[DllImport("LibEncrypt.dll",
EntryPoint=" mySum ",
CharSet=CharSet.Ansi,CallingConvention=CallingConvention.StdCall)]
public static extern string mySum (string a, string b);
}
在C#中再调用测试：

string strDest="";
string strTmp= RefComm. mySum("45", ref strDest);
运行查看结果 strTmp 为"45"，但是串 strDest 没有赋值。第二步实现函数返回串，但是在函数出口参数中没能进行输出。再次修改 C# 导入定义，将串b修改为引用（ref）：

public class RefComm
{
[DllImport("LibEncrypt.dll",
EntryPoint=" mySum ",
CharSet=CharSet.Ansi,CallingConvention=CallingConvention.StdCall)]
public static extern string mySum (string a, ref string b);
}

运行时调用失败，不能继续执行。

第三步，修改动态链接库实现，将b修改为双重指针：

LIBEXPORT_API char *mySum(char *a,char **b){sprintf((*b),"%s",a); return *b;}
C#导入定义：

public class RefComm
{
[DllImport("LibEncrypt.dll",
EntryPoint=" mySum ",
CharSet=CharSet.Ansi,CallingConvention=CallingConvention.StdCall)]
public static extern string mySum (string a, ref string b);
}
在C#中调用测试：

string strDest="";
string strTmp= RefComm. mySum("45", ref strDest);

运行查看结果 strTmp 和 strDest 均为"45"，调用正确。第三步实现了函数出口参数正确输出结果。

第四步，修改动态链接库实现，实现整数参数的输出：

LIBEXPORT_API int mySum(int a,int b,int *c){ *c=a+b; return *c;}
C#导入的定义：

public class RefComm
{
[DllImport("LibEncrypt.dll",
EntryPoint=" mySum ",
CharSet=CharSet.Ansi,CallingConvention=CallingConvention.StdCall)]
public static extern int mySum (int a, int b,ref int c);
}
在C#中调用测试：

int c=0;
int iSum= RefComm. mySum(,, ref c);

运行查看结果iSum 和c均为5，调用正确。

经过以上几个步骤的试验，基本掌握了如何定义动态库函数以及如何在 C# 定义导入，有此基础，很快我实现了变长加密函数在 C# 中的调用，至此目标实现。

三、结论

在 C# 中调用 C++ 编写的动态链接库函数，如果需要出口参数输出，则需要使用指针，对于字符串，则需要使用双重指针，对于 C# 的导入定义，则需要使用引用（ref）定义。

对于函数返回值，C# 导入定义和 C++ 动态库函数声明定义需要保持一致，否则会出现函数调用失败。定义导入时，一定注意 CharSet 和 CallingConvention 参数，否则导致调用失败或结果异常。运行时，动态链接库放在 C# 程序的目录下即可，我这里是一个 C# 的动态链接库，两个动态链接库就在同一个目录下运行。

❾ VC程序调用动态库,编译时候也跟着编译动态库

不太清楚你的工程是如何建立的，想必一个工程是生成动态链接库，另一个是调用程序EXE了。由于VC动态库有两种形式，Regular和Extended两种，其中一种能导出类，另一种只能导出变量和函数。如果导出的是类，你在编译EXE文件时自然需要用到类得声明文件，即你前面所说的动态库本身所引用的文件。如果导出的是函数或变量，有可能出现的情况是：一般为了代码的重用性，把需要导出的函数或变量单独放在一个头文件中，用一个宏控制其导入、导出。编译动态库时，宏定义为导出，编译EXE时，宏变为导入，这个头文件为两者共用。如果不小心在这个头文件中包含了其他头文件，也可能出现你说的情况。如果动态库调用直接采用函数入口地址的方法，则什么都不用声明，当然，只适用于导出函数与变量的情形。

❿ linux 静态库和动态库编译的区别

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