编译静态库代码有什么要求

① 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

② vs 命令行编译静态库

_declspec(dllexport) void test_print(char* sz_input);
这是动态链接库 -- dllexport ，dll是动态链接库。
不是你说的静态库。
动态链接库，应用程序调用它，编译链接时要有.lib, 运行时要有.dll

Debug\ -- 给别的程序用，要用 Release\，不能用 Debug\

char * __ptr64 sz_input;
__ptr64 -- 32位机上，指针sz_input截断为32位.
char * __ptr32 sz_input;
__ptr32 -- 64位机上,指针sz_input变32位

wchar_t，_MBCS -- 表明你要用双字节字符，那么程序就不应当用 单字节char 型。如果你要编的不是要用双字节字符，那么 就不要 wchar_t，_MBCS。

③ C语言编译问题 静态链接

静态链接相当于你把静态库也加到二进制文件里面去了。动态的话，只是指明了需要什么动态库，这个库在什么位置。你换一台机器的话，编译静态库的二进制文件是可以执行的。动态库的二进制文件则需要对应目录有需要的动态库才可以执行。多个程序都编译同一个静态库，那么多个二进制文件执行时都需要加载静态库这部分代码。如果是动态库，那么多个二进制文件只需要在内存里面有一份这个动态库部分的代码。

④ 静态库文件全部编译成目标码吗

不可以。
只有静态库中的可执行文件可以编译成目标码。
程序编译一般需经预处理、编译、汇编和链接几个步骤。在我们的应用中，有一些公共代码是需要反复使用，就把这些代码编译为“库”文件，在链接步骤中，连接器将从库文件取得所需的代码，复制到生成的可执行文件中。这种库称为静态库，其特点是可执行文件中包含了库代码的一份完整拷贝，缺点就是被多次使用就会有多份冗余拷贝。

⑤ 如何编译生成和调用静态库

如何编译动态库
gcc test1.c test2.c -shared -fPIC -o libtest.so
使用动态库
gcc main.c -L. -ltest -o a.out
(
-L : 表示需要库的路径
-l：表示需要库的名称，如libtest.so，名称则为test
)
（ps：执行a.out时有可能提示找不到libtest.so文件，这时需要把库文件放入到/lib等目录下，或者添加环境变量LD_LIBRARY_PATH，包含有库文件的路径即可）

如何编译静态库
gcc -c test1.c test2.c
ar -r libtest.a test1.o test2.o
使用静态库
gcc main.c -static -L. -ltest -o a.out
（
-static：可强制编译时使用静态库，如果不使用这个参数，而静态库与动态库同名的话，会优先使用动态库

⑥ 创建静态库/动态库一定要有头文件吗为什么

不一定需要。创建一个库一般处于一下两种目的：
1、把一些相关的代码，打包成一个库，发布给其它的人用。
这中情况是最常见的情况，如写 C 语言用到 libgcc。在这种情况下，你除了提供库文件：静态库[ windows 下 .lib，linux .a]；动态库：[Windows 下 .dll，Linux 下 .so] 之外，必须提供头文件。头文件是你这个库里面提供了那些接口可以供外界使用。如果没有头文件，其他人无法使用。

2、为某些软件写插件。
很多大的项目，都是模块化设计，留有一些特定的接口，方便定制。当程序运行时，会动态加载制定目录下的动态库，运行时调用动态库里面约定好的方法。
这种情况无需提供头文件，但要按照特定的约定来实现这个库。

大概就是以上这些情况。

⑦ 什么叫静态库和动态库

两者区别：
一，静态库的使用需要：
1
包含一个对应的头文件告知编译器lib文件里面的具体内容
2
设置lib文件允许编译器去查找已经编译好的二进制代码
二，动态库的使用：
程序运行时需要加载动态库，对动态库有依赖性，需要手动加入动态库
三，依赖性：
静态链接表示静态性，在编译链接之后，
lib库中需要的资源已经在可执行程序中了，
也就是静态存在，没有依赖性了
动态，就是实时性，在运行的时候载入需要的资源，那么必须在运行的时候提供
需要的
动态库，有依赖性，
运行时候没有找到库就不能运行了
四，区别：
简单讲，静态库就是直接将需要的代码连接进可执行程序；动态库就是在需要调用其中的函数时，根据函数映射表找到该函数然后调入堆栈执行。
做成静态库可执行文件本身比较大，但不必附带动态库
做成动态库可执行文件本身比较小，但需要附带动态库
五：
首先纠正所谓“静态连接就是把需要的库函数放进你的exe之中”的说法。在真实世界中，有三个概念：use
static
libary,
static
linked
dll,
dynamic
linked
dll.
多数人混淆了static
libary
和
static
linked
dll的概念，当然他们有似是而非的“相似之处”，比如都用到.lib，下面具体说明。
使用静态库(use
static
libary)是把.lib和其他.obj一起build在目标文件中，目标文件可以是.exe,也可以是.dll或.oxc等。一般情况下，可以根本就没有“对应的”.dll
文件，如c
run
time(crt)库。一个例子就是，写一个main(){}，build出来并不是只有几个字节，当然有人会说那还有exe文件头呢？是，即使加上文件头的尺寸，build出的执行文件仍然“莫名的大”。实际上那多出来的部分就是crt静态库。姑且可以把静态库.lib理解成外部程序的obj文件比较合理，它包含了函数的实现。

⑧ 简述gcc编译时使用静态库和动态库的区别

函数库分为静态库和动态库两
种。静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。动态
库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运
行时还需要动态库存在。

⑨ android已有动态库怎么编译静态库

在eclipse工程目录下建立一个jni的文件夹
在jni文件夹中建立Android.mk和Application.mk文件

Android.mk文件：

Android提供的一种makefile文件，用来指定诸如编译生成so库名、引用的头文件目录、需要编译的.c/.cpp文件和.a静态库文件等。详见附件中的Android.mk。

Application.mk文件：

定义了项目的一些细节，比如APP_ABI := x86(编译X86平台库)、APP_PLATFORM := android-9(使用android-9以上的平台库)。

NDK 编译和使用静态库、动态库
情况一：编译静态库
情况二：编译动态库
情况三：编译动态库+静态库
情况四：已有第三方静态库（动态库），编译静态库（动态库）

默认所有代码和文件在$project/jni下，否则特殊说明。
情况一：编译静态库
文件Android.mk:
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := hello-jni
LOCAL_SRC_FILES := hello-jni.c
include $(BUILD_STATIC_LIBRARY)

文件Application.mk:
APP_MODULES :=hello-jni

情况二：编译动态库
文件Android.mk:
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := hello-jni
LOCAL_SRC_FILES := hello-jni.c
include $(BUILD_SHARED_LIBRARY)
情况三：编译动态库+静态库
文件Android.mk:
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := mylib_static
LOCAL_SRC_FILES := src.c
include $(BUILD_STATIC_LIBRARY)
include $(CLEAR_VARS)
LOCAL_MODULE := mylib_shared
LOCAL_SRC_FILES := src2.c
LOCAL_STATIC_LIBRARIES := mylib_static
include $(BUILD_SHARED_LIBRARY)
情况四：已有第三方静态库(动态库)，编译静态库(动态库)
文件Android.mk:
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := thirdlib1 # name it whatever
LOCAL_SRC_FILES := $(TARGET_ARCH_ABI)/libthird1.a # or $(so_path)/libthird1.so
#LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include
include $(PREBUILT_STATIC_LIBRARY) #or PREBUILT_SHARED_LIBRARY
include $(CLEAR_VARS)
LOCAL_MODULE := mylib_use_thirdlib
LOCAL_SRC_FILES := src.c
LOCAL_STATIC_LIBRARIES := thirdlib1 #or LOCAL_SHARED_LIBRARY

include $(BUILD_SHARED_LIBRARY) #如果编译静态库，需要Application.mk
用cd命令移至jni目录，运行/mnt/500G/public/NDK/android-ndk-r7b/ndk-build命令，这时命令行中可能会出现编译错误，比如头文件找不到，函数找不到等等，细心找找就能改掉。
编译成功后，在工程目录下libs/x86中就会生成你想要的.so库。

⑩ 如何编译C/Fortran动态/静态链接库

首先，传统的编译，也就是静态编译是把 源文件 翻译成目标文件，这个是一次性过程，也就是你所谓的静态编译。
后来的Java和.NET等语言，首先编译成中间形式，然后运行过程中根据需要编译成本地代码（注意这个过程不是一次性的，下次运行重新编译），这个就是JIT（即时编译）技术，从即时编译发展出了动态编译技术
————————————
（传统的）编译完成后，像C/C++、Fortran、汇编等语言，可以把多个目标文件合并到一个库文件中，这个就是静态库。比如常说的库函数printf就是libc里面的函数。
如果有了启动函数（main），main里面使用了printf，就可以通过静态链接技术，从libc中提取出printf所在的文件加入到可执行文件中，如果printf还需要其它函数，就继续搜索并加入列表，直到形成一个闭包。这个就是静态链接。
可是静态链接有个明显的缺点，如果每个程序都需要printf，那么printf这个函数的代码就会同时存在在每个程序中，这样也太占地方了吧。所以发明了动态连接技术，其实有两种形式。无论哪一种，都是首先记录下需要调用printf这个函数以及所在的动态库，等到运行的时候再加载动态库，从动态库中找到真正的printf去执行。
由于，动态链接技术需要一些额外的信息，传统的静态库是不具备的，这些额外信息主要是重复加载和卸载时所需要的一些代码，因此需要动态链接库。