精华内容
下载资源
问答
  • C语言中的静/动态库文件

    千次阅读 2019-05-03 17:52:51
    C语言中的静/动态库文件 文章目录C语言中的静/动态库文件起因编译函数库静态库动态库感谢 起因 之前一直对 .a、.so 文件的存在犯迷糊。现在想来,之所以当时会有不解,是因为从没用 C 语言写过项目,顶多只是语法的...

    C语言中的静/动态库文件



    起因

    之前一直对 .a.so 文件的存在犯迷糊。现在想来,之所以当时会有不解,是因为从没用 C 语言写过项目,顶多只是语法的测试,以及一些算法实现。现在略微搞明白些了,于是有了这篇总结。

    编译

    当尝试在终端敲入 gcc -o test test.c 时,其实就是告诉编译器,请把我的代码(test.c)编译成一个可执行文件(test)。在这个短短过程中,代码经历了四个阶段,分别是:1. 预处理阶段 2. 编译阶段 3. 汇编阶段 4. 链接阶段。

    不同阶段有不同的事儿要做,从头至尾如下:

    • 预处理阶段:1. 删除注释 2. 宏替换 3. 条件编译 4. 将头文件放到 .c 文件中,最后生成 .i 文件;(gcc -E -o test.i test.c
    • 编译阶段:将 C 语言翻译成汇编语言,生成 .s 文件;(gcc -S -o test.s test.i
    • 汇编阶段:将汇编翻译成机器语言,生成 .o 文件;(gcc -o test.o -c test.s
    • 链接阶段:将 .o 文件链接生成可执行文件。(gcc -o test test.o

    在上述四个阶段中,.i 和 .s 都是文本文件,你可以打开来看看里面都写着啥。后两个阶段是二进制文件,你想打开看,那就看一堆乱码。也并非束手无措,可以用 objdump 命令反汇编。像下面这样:

    root@hui:make$ objdump -xd test.o
    
    test.o:     file format elf64-x86-64
    test.o
    architecture: i386:x86-64, flags 0x00000011:
    HAS_RELOC, HAS_SYMS
    start address 0x0000000000000000
    ...
    

    函数库

    前面唠叨那么多,就是想引出 .o 文件。

    函数库,顾名思义:里边存放了一堆供程序员使用的函数。其实不但有函数名、函数对应的实现代码,还有链接过程中所需的重定位信息。

    函数库分为静态库(.a 文件)和动态库(.so)文件。 Linux 中,标准的 C 函数库放在 /usr/lib 目录下;而用户,也可以根据自生需求,建立自己的用户函数库。

    这里需要注意,由于函数库来自于 .o 文件,也就是说,是一堆二进制文件构成,你看不到里面的库函数代码。所以库函数该怎么用呢?这就体现了头文件中的重要性。所以 .h 文件与 .c 最好是要分开写。

    静态库

    静态库是一些 .o 目标文件的集合,以 .a 结尾,在程序链接的时候使用。链接器会将程序中使用到的函数代码从库文件中拷贝到可执行文件里边,完成链接后,可执行文件不需要静态库也能独立执行。

    静态库的创建方式:

    $ ar rcs lib库文件名.a 目标文件1.o 目标文件2.o 目标文件3.o ...
    

    参数说明:

    • r 表示将 .o 的目的文件加入到静态库中;
    • c 表示创建静态库;
    • s 表示生成索引。

    创建的库文件名字前面最好加上前缀 lib ,方便编译器找到它。(你可以认为这是一种规范)

    静态库的使用方式:

    $ gcc -o 可执行文件 源码.c -I[头文件目录] -L[库文件目录] -l[库文件]
    
    $ gcc -o 可执行文件 目标文件.o -L[库文件目录] -l[库文件]
    

    参数说明:

    • -L 表示将指定库文件所在目录加入到库搜索路径中去,默认库搜索路径为 /usr/lib 目录;
    • -l(小写 L) 表示库搜索路径下的某个库文件。需要注意,如果你的库文件名以 lib 开头,如:libguan.a ,那么配合该参数时直接 -lguan 即可;如果不是 lib 开头,则不能用 -l 参数,而是直接指明 .a 文件的路径。
    • -I(大写 i),表示指明头文件的所在目录。

    举例简单说明一下用法。

    这里有目录 demo ,目录结构如下:

    root@hui:test$ tree demo/
    demo/
    ├── include
    │   └── guan.h
    └── src
        ├── guan.c
        └── main.c
    
    2 directories, 3 files
    

    guan.h 文件提供函数声明,内容如下:

    // root@hui:demo$ cat include/guan.h 
    #ifndef __GUAN_H__
    #define __GUAN_H__
    
    #include <stdio.h>
    #include <stdarg.h>
    
    void print(char *fmt, ...);
    
    #endif
    

    guan.c 源码文件存放函数 print 的定义:

    // root@hui:demo$ cat src/guan.c 
    #include "guan.h"
    
    void
    print(char *fmt, ...) {
        
        char msg[1024 * 4] = {};
        va_list sp;
        
        va_start(sp, fmt);
        vsprintf(msg, fmt, sp);
        va_end(sp); 
    
        printf("%s:", "Guan");
        printf("%s\n", msg);
    }
    

    在主程序 main.c 文件中,调用 print() 函数:

    // root@hui:demo$ cat src/main.c 
    #include <stdio.h>
    #include "guan.h"  // 注意,需要映入头文件
    
    int main()
    {
        print("%s", "怀念我跑进雨天的冒险。");
    }
    

    现在,我们先在当前目录下创建一个 lib 目录,用来存放生成的 .a 静态库文件。在这之前,我们还需要生成 .o 结尾的目标文件。操作如下:

    root@hui:demo$ gcc -o src/guan.o -c src/guan.c -Iinclude  # 生成 .o 的目标文件
    root@hui:demo$ tree src/
    src/
    ├── guan.c
    ├── guan.o  # 文件生成
    └── main.c
    
    0 directories, 3 files
    root@hui:demo$ mkdir lib  # 创建 lib 目录,用于存放 .a 文件
    root@hui:demo$ ls
    include  lib  src
    root@hui:demo$ ar rcs lib/libguan.a src/guan.o  # 生成 .a 文件
    root@hui:demo$ tree lib/
    lib/
    └── libguan.a  # 文件生成
    
    0 directories, 1 file
    root@hui:demo$ mkdir bin  # 创建 bin 目录,用来存放可执行文件
    root@hui:demo$ ls
    bin  include  lib  src
    root@hui:demo$ gcc -o bin/app src/main.c -Iinclude -Llib -lguan  # 生成可执行文件 app
    root@hui:demo$ bin/app  # 运行可执行文件
    Guan:怀念我跑进雨天的冒险。  # 可执行文件的输出结果
    

    如果生成 .a 文件时,没有用 lib 作为前缀,那么编译 main.c 时命令应该如下这样:

    gcc -o bin/app2 src/main.c -Iinclude lib/guan.a
    

    前面说静态库的使用时,有两种使用方式,第一种上面已经说过了。第二种,就是先把 main.c 生成 main.o 的目标文件,这样一下,生成执行文件时,就不需要指定头文件的目录了。

    root@hui:demo$ gcc -o src/main.o -c src/main.c -Iinclude   # 生成 main.o 文件
    root@hui:demo$ ls src/ |grep main
    main.c
    main.o
    root@hui:demo$ gcc -o bin/app3 src/main.o -Llib -lguan  # 生成可执行文件 app3
    root@hui:demo$ bin/app3  # 执行可执行文件
    Guan:怀念我跑进雨天的冒险。
    

    动态库

    动态库又叫作共享库,在 linux 中以 .so 结尾。与静态库不同在于,动态库不会直接把调用的代码拷贝到执行程序中去,而是在执行程序中作下标记,等到程序运行时才去加载需要的函数。这就意味着执行程序在运行时需要动态库做支持,自己不能独立执行。这样做的好处是:如果某个模块修改了代码,不需要将整个程序都重新编译,而是编译一部分,生成新的 .so 文件即可。

    同时,动态库链接出来的执行文件会比静态库要小得多。

    动态库的创建方式:

    # 第一种方式
    gcc -fPIC -o 目标文件1.o -c 非主程序源码1.c
    ...
    gcc -shared -o lib库文件名.so 目标文件1.o 目标文件2.o ...
    
    
    # 第二种方式
    gcc -fPIC -shared -o lib库文件名.so 非主程序源码.c
    

    参数说明:

    • -shared 表示使用共享库(动态库);
    • -fpci 表示创建产生独立目标代码。

    动态库文件的生成稍稍比静态库文件麻烦些。先生成 .o 的目标文件时,一定要加上 -fpic 这个参数,然后生成 .so 文件时,不要忘了 -shared 参数。也可以把 .c 到 .so 这个过程合并起来,也就是上边说的第二种方法。如果仍以之前的目录结构为例,命令就应该像下面这样:

    gcc -shared -fpic -o lib/libguan.so src/guan.c -Iinclude  # 生成动态库文件
    

    动态库的使用方式:

    gcc -o 可执行文件 源码.c -I[头文件目录] -L[库文件目录] -l[库文件]
    
    gcc -o 可执行文件 目标文件.o -L[库文件目录] -l[库文件]
    

    这同使用静态库一样。但需要注意的是,由于链接动态库的执行程序在运行过程中会用到里边的库函数,那么执行程序必须知道动态库在哪里。怎样看执行程序知不知道动态库在哪里呢?执行一下咯!

    倒也不是开玩笑,看程序是否能够正常执行可以鉴别它知不知道动态库在哪里。但不执行程序,也可以知道。这里需要用到命令:ldd

    root@hui:demo$ ldd bin/app 
            linux-vdso.so.1 =>  (0x00007ffe403a2000)
            libguan.so => not found  # 注意,没找到动态库
            libc.so.6 => /lib64/libc.so.6 (0x00007f1faa60e000)
            /lib64/ld-linux-x86-64.so.2 (0x00007f1faa9db000)
    

    解决方案有三种:

    • 第一种:将动态库文件放到 /usr/lib 目录下(但要注意,我上面输出 libc.so.6 那一行是在 /lib64 目录下找到的,所以我的环境里需要把动态库文件放到 /usr/lib64 这个目录下);
    • 第二种:使用命令:export LD_LIBRARY_PATH=库文件目录 (只在声明时的所在终端有效)
    • 第三种:vim /etc/ld.so.conf;在配置文件中加入 lib 目录的绝对路径,保存退出;执行命令 ldconfig

    如果程序运行过程中动态库文件被删除,程序就不能正常运行下去。

    感谢

    • 参考 海同网校王正平老师的 C 语言之多模块软件的编译和链接
    展开全文
  • 近期正在做在Ubuntu环境下将C++程序封装成动态库文件和静态库文件,期间不知道掉了多少坑,在这里写下来以免忘记工作是将实现MTCNN的C++源代码封装成动态库文件和静态库文件,原先在github上找到了一个依据opencv和...

    近期现学现做一个在Ubuntu环境下将C++程序封装成动态.so库文件和静态.a库文件的小项目, 期间不知道掉了多少坑,所以在这里记录下来与诸君共勉

    一、静态库和动态库

    本质上来说库是一种可执行代码的二进制形式,可以被操作系统载入内存执行,库可分成静态库和动态库(共享库),在Windows系统下,分别对应着xx.lib和xx.dll文件,在linux系统下,分别是xx.a和xx.so文件。

    1.静态库

    静态库的命名形式是libname.a.静态库的代码在编译过程中已经被载入可执行程序,因此体积较大。它的优点是,编译后的执行程序不需要外部的函数库支持,因为所有使用的函数都已经被编译进可执行文件了。同样它的不足,如果静态函数库改变了,那么你的程序必须重新编译,而且体积也较大。

    2.动态库

    动态库名字一般是libname.so.相对于静态函数库,共享库的代码是在可执行程序运行时才载入内存的,在编译过程中仅简单的引用,因此代码体积较小由于函数库没有被整合进你的程序,而是程序运行时动态申请并调用,所以程序的运行环境中必须提供相应的库。动态函数库的改变并不影响你的程序,所以动态函数库的升级比较方便。而且如果多个应用程序都要使用同一函数库,动态库就非常适合,可以减少应用程序的体积。

    静态库和动态库的主要区别在于:静态库是在程序编译时被链接到目标代码中,而动态库是在程序运行时才被载入。

    二、生成动态库和静态库

    一开始找的MTCNN的源代码是依赖于opencv和openblas环境,说起配置环境又是一把辛酸泪,在这里不再赘述,源码中头文件和cpp文件数量不多,所以采用的是用g++的方式生成库文件,可是在测试的时候,能够在没有配置opencv的环境下直接调用程序所需要的库文件,但是却不能在没有openblas的环境下调用libopenblas库文件,所以当时就放弃了这种方案。

    1.用g++方式分别创建静态和动态库文件

    在linux系统下,是用命令ar处理A.o目标文件生成静态库文件,需要指令如下:

    1.g++ -c  A.cpp  -o A.o
    2.ar -cr libA.a A.o
    3.ar -r libABC.a  *.o

    第一条指令是编译A.cpp 生成 A.o文件

    第二条指令是生成静态库文件,在-cr后面的参数就是库文件的名字

    第三条指令是将目录下的所有的.o文件合并生成静态库

    在linux下编译时,通过 -shared 参数可以生成动态库.so文件,如下:

    g++ -shared -fPIC -o libA.so A.o

    -shared 该选项指定生成动态连接库,不用该标志外部程序无法连接。相当于一个可执行文件
    -fPIC:表示编译为位置独立的代码,不用此选项的话编译后的代码是位置相关的,所以动态载入时是通过代码拷贝的方式来满足不同
    进程的需要,而不能达到真 正代码段共享的目的。

    2.使用cmake方式创建静态库和动态库文件

    很幸运地是,我们又找到了一个不依赖任何第三方库的C++源程序代码,可是此源码的头文件和CPP文件的数量巨大,而且代码具有层次感,其中还有子文件夹,所以在这个时候,用Cmake方式创建库文件是很高效间接的手段。

    采用out-of-source编译的方式,按照习惯,建立一个build目录,将源程序文件放入build目录下,并在build目录下编写CMakeLists.txt,这个文件是cmake的构建定义文件,文件名是大小写相关的。为了能同时生成动态库文件和静态库文件,CMakeLists.txt文件中的相应内容如下:

    1.add_library(name SHARED source1, source2, ..., sourceN)
    2.add_library(name_static STATIC source1, source2, ... , sourceN)
    3.set_target_properties(name_static PROPERTIES OUTPUT_NAME "name")
    4.set_target_properties(name_static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
    5.set_target_properties(name PROPERTIES CLEAN_DIRECT_OUTPUT 1)
    6.set_target_properties(name PROPERTIES VERSION 1.2 SOVERSION 1)
    7.install(TARGETS name name_static 
              LIBRARY DESTINATION lib
              ARCHIVE DESTINATION lib)
    8.install(DIRECTORY ${titile_H} DESTINATION include/tH)

    第一条指令是生成动态库(扩展名为.so),类型关键字是SHARED,并不需要写全libname.so,只需要填写name即可,cmake系统会自动生成libname.so。

    第二条指令是在支持动态库的基础上为工程添加一个静态库,因为静态库和动态库同名时,构建静态库的指令是无效的,所以把上面的name修改为name_static,就可以构建一个libname_static的静态库;然而我们需要的是名字相同的静态库和动态库,因为target的唯一性,所以就不能通过add_library指令实现,所以用到第三条指令

    第三条指令是为了能够同时得到libname.so/libname.a两个库文件,但是因为cmake在构建一个新的target时,会尝试清理掉具有相同命名的库文件,所以,在构建libname.a的时候会将libname.so库文件清理掉,因此需要再次使用set_target_properties定义的CLEAN_DIRECT_OUTPUT属性,如第四条和第五条指令所示,至此,我们再次进行构建,就会发现在目录中同时生成libname.so动态库文件和libname.a静态库文件

    第六条指令是因为按照规则,动态库是应当包含一个版本号的, 为了实现动态库版本号,仍然需要使用SET_TARGET_PROPERTIES指令,其中VERSON指代动态库版本,SOVERSION指代API版本。

    第七条指令是将动态库和静态库文件安装到系统目录,才能够真正地让其他人开发使用,我们将库文件安装到<prefix>/lib目录下

    第八条指令是将头文件安装到<prefix>/include/tH目录中。

    在终端进入build目录的上级目录,输入命令行,命令如下:

    cmake build

    make

    sudo make install

    至此,我们就可以将头文件和库文件分别安装到系统目录/usr/local/include/tH/和usr/local/lib中了。

    三、外部引用动态库和静态库和头文件

    构建和安装动态库和静态库之后,为了测试库文件是否被外部调用,需要编写源文件main.cpp进行函数调用测试。同样,我们还是使用cmake方式进行编译

    3.1 外部引用静态库文件

    1.INCLUDE_DIRECTORIES(头文件在系统中的位置)
    2.ADD_EXECUTABLE(main source/main.cpp)
    3.TARGET_LINK_LIBRARIES(main libfaceDetection.a)

    第一条指令是引用头文件搜索路径

    第二条指令的作用是生成一个名为main的可执行文件

    第三条指令是位target添加静态库

    3.2 外部引用动态库文件

    因为编译安装将动态库安装到/usr/local/lib目录下,对于动态库的外部引用有些麻烦,稍后补上





    展开全文
  • vs2015添加动态库文件路径

    千次阅读 2017-03-29 14:10:58
    添加动态库文件: 1.把dll文件放在与exe文件同级目录下,就可以运行exe文件。 2.通过window下环境变量里添加即可。 注:在进行编译的时候,vs编译器没有调用到lib文件,而是只调用dll文件。当运行exe文件的时候,才...

    添加动态库文件的两种方法:

    1.把dll文件放在与exe文件同级目录下,就可以运行exe文件。

    2.通过window下环境变量里添加即可运行exe文件。

    注:在进行编译的时候,vs编译器没有调用到lib文件,而是只调用dll文件。当运行exe文件的时候,才会调用到dll文件。






    展开全文
  • java调用dll动态库文件的一般总结

    万次阅读 2017-02-17 10:46:21
    前一段时间,在项目需求中,需要调用一下第三方的动态库文件,下面是本人一些尝试的经历。  首先需要明白的是,在java中是不能直接调用动态库文件的,因为动态库文件是使用c或是c++编写的,作为一种跨 平台的编程...

      前一段时间,在项目需求中,需要调用一下第三方的动态库文件,下面是本人一些尝试的经历。

      首先需要明白的是,在java中是不能直接调用动态库文件的,因为动态库文件是使用c或是c++编写的,作为一种跨     平台的编程语言,java提供了一些用来读取dll文件方法,

      一种是直接用JNI,这种方法一般来说用的人比较少,因为其中涉及到c++调用文件的编写,这里就不再叙述,下面直接说我们java程序员常用的两种调用动态库的方法

       1.Jna调用动态库,

        JNA(Java Native Access )提供一组Java工具类用于在运行期动态访问系统本地库(native library:如Window的dll)而不需要编写任何Native/JNI代码。开发人员只要在一个java接口中描述目标native library的函数与结构,JNA将自动实现Java接口到native function的映射。

       使用步骤:

         (1):调入jar包,使用Jna之前我们需要在项目中首先导入Jna的jar包,有两个,jna-3.3.0-platform.jar 和 jna.jar

         (2):将需要调用的第三方dll文件放在项目的根目录下

         (3):编写调用的方法

            import com.sun.jna.Native;
            import com.sun.jna.win32.StdCallLibrary;
            public class HelloWorld {
        public interface Dll extends StdCallLibrary { 

     
                Dll INSTANCE = (Dll) Native.loadLibrary("SiInterface", Dll.class);//加载动态库文件


                public int INIT();//动态库中调用的方法
           }
        public static void main(String[] args) {
    System.out.println(Dll.INSTANCE.INIT());
          }
          }

         需要注意:当dll文件不在项目的根目录下,路径要写成绝对路径

        2.Jnative调用动态库

         使用步骤:

        (1):首先下载JNative的jar包,其中包含JNative.jar, JNativeCpp.dll, libJNativeCpp.so这三个包。

                JNative.jar是需要导入到Java工程的lib下。 通过Build Path即可导入。 建议将JNative.jar放在jdk的jre\lib\ext文             件里。

               JNativeCpp.dll是必须放入到jdk的jre\bin文件里,否则就会报JNative找不到的错误。

                libJNativeCpp.so是Linux操作系统的,由于没有做过实验,所以暂时不予说明。

       (2):由于  JNativeCpp.dll是32为windows程序,所以需要下载jdk 32位的版本才可以。这一点要注意了

       (3):将需要调用的dll动态链接库放置到system32文件里,否则就会出现找不到dll文件的错误。

       (4):下面是代码部分

         import java.io.IOException;
         import java.io.PrintWriter;
         import javax.servlet.ServletException;
         import javax.servlet.http.HttpServlet;
         import javax.servlet.http.HttpServletRequest;
         import javax.servlet.http.HttpServletResponse;
         import org.xvolks.jnative.JNative;
         import org.xvolks.jnative.Type;
         import org.xvolks.jnative.exceptions.NativeException;
         public class testServlet extends HttpServlet {
      static JNative jnt = null; 
      public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    try {
    String  filePath =request.getSession().getServletContext().getRealPath("/");  
                    //下面用的是文件的绝对路径
                  System.load("D:\\myeclipse\\JnaWeb\\WebRoot\\jna\\SiInterface.dll");
             if (jnt == null) {  
                 // 1.利用org.xvolks.jnative.JNative来加载DLL:参数1.类名  
                 // 2.方法名  
                 jnt = new JNative("SiInterface.dll", "INIT");  
                 jnt.setParameter(0, "error");
                 // 3.设置返回参数的类型  
                 jnt.setRetVal(Type.INT);  
                 // 4.执行方法  
                 jnt.invoke();// 调用方法  
             } 
             // 5.返回值  
             String string=jnt.getRetVal(); 
             System.out.println("string="+string);
         } catch (NativeException e) {
    e.printStackTrace();
    } catch (IllegalAccessException e) {
    e.printStackTrace();
    } finally {  
             if (jnt != null) {  
                 // 6.释放系统资源  
                 try {
    jnt.dispose();
    } catch (NativeException e) {
    e.printStackTrace();
    } catch (IllegalAccessException e) {
    e.printStackTrace();
    }  
             }  
         } 
    }
    public void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
    }
    }


       

    展开全文
  • 最近要用到的签名算法只给了一堆源码没有给库文件,api都不好调用,于是尝试着用Makefile给一堆c源码编译静态链接库文件动态链接库文件。Makefile文件编辑的相关资料链接:...
  • CMake教程(一)- 添加库文件什么是库文件如何在CMake中添加库文件 什么是库文件 如何在CMake中添加库文件
  • 1、so动态库文件的生成; 首先编写.c源文件和.h头文件; 使用gcc编译工具编译生成.so文件 gcc -shared source.c -o libname.so 或gcc -shared -fPIC source.c -o libname.so -fPIC具体的意思需要查一下; ...
  • 原文转自 :... 文件目录结构如下 1 dynamiclibapp.c 2 Makefile 3 comm/inc/apue.h 4 comm/errorhandle.c 5 dynamiclib/Makefile 6 dynamiclib/dynamiclib_add.c 7 d
  • 1、需要定影的dll动态库文件 比如 : FileEncryption.dll 2、需要该动态库的头文件  头文件为 interface.h #ifndef __INTERFACE_H__ #define __INTERFACE_H__ #ifndef __PUBLIC_H__ #include "public.h&...
  • 一、VS2013动态库文件的创建 1、新建项目,win32,win32项目,输入项目名称,例如MakeDll。   2、”确定“——”下一步“,选择”DLL“选项,再点”完成“:   3、菜单栏选择”项目“——>...
  • 本文介绍了如何改变 OpenSSL 编译后生成动态库文件的默认名。
  • Objdump查看依赖so动态库文件

    万次阅读 2012-10-11 15:42:14
    在做系统跨平台移植的时候,需要知道生成的o文件需要的so动态库文件,就可以使用下命令了。 zchx@ubuntu:~/workspace/mips_UDP/g++build$ ls a.out UDP_Multicast.cpp zchx@ubuntu:~/workspace/mips_UDP/...
  • 动态库文件dll生成lib库文件

    万次阅读 2014-06-18 11:02:55
    本文基于OpenBlas的编译和安装,来说明如何从一个dll文件生成lib库文件。 参考OpenBlas的说明“Howto generate import library for MingW”,和MinGW的说明HOWTO Create an ImportLibrary for a DLL using MinGW,...
  • 在linux平台下的不通机器间移动动态库文件会遇到链接不到库的问题,可需要连接的库明明就在目录下,这时你就需要对这些库进行处理了。 首先删除动态库在移动前生成的软链接,然后重新生成一遍,最后修改/...
  • c++mfc头文件库文件动态库 目录(?)[+] .h头文件是编译时必须的,lib是链接时需要的,dll是运行时需要的。 附加依赖项的是.lib不是.dll,若生成了DLL,则肯定也生成 LIB文件。如果要完成源代码的...
  • 我在eclipse 的项目里动态导入so文件,而且代码部分不报错,但是闪退这为什么
  • ...附加依赖项的是.lib不是.dll,若生成了dll,则肯定也生成lib文件。如果要完成源代码的编译和链接,有头文件和lib就够了。如果要使需要动态连接的程序运行起来,有dll就够了。在开发和调试阶
  • 如何让C#生成的dll动态库文件,在被引用时带有注释备注提示
  • 一,VS2013动态库文件的创建 1.新建项目,win32,win32项目,输入项目名称,例如:MakeDll。 2.“确定”---“下一步”,选择“DLL”选项,再点“完成”: 3.菜单栏选择“项目—>添加新项”,来创建...
  • C/C++ 生成动态库文件(dll)

    千次阅读 2019-02-28 15:20:20
    功能模块的入口函数是指你开发的程序的对外的接口,也就是说生成动态库后,其他程序通过这个接口函数来使用你开发的功能。 1. 入口函数在声明时要加上“__declspec(dllexport)”,表明这是一个...
  • realname:实际等同于库文件的filename,是在库文件生成时就被指定的,如:gcc -shared -o $(realname) dependence flagsrealname的一般格式为 lib$(name).so.$(major).$(minor).$(revision),$(name)是动态库的名字...
  • 获取动态库文件句柄 # include # include # include using namespace std ; int main ( ) { const char * p = "./SMBA.so" ; void * handle = dlopen ( p , RTLD_LAZY )...
  • QT Creator中调用动态库文件例程

    千次阅读 2014-04-15 08:58:59
    在linux中,qt里面已经集成了最新的开发平台QT Creator,下面是我练习调用动态库(.so文件)的例程:  1、打开QT Creator,点击File-》New...菜单,选择C++ Libarary工程,点击下一步,输入工程名称(本例为zsz)...
  • 不同语言之间可以通过调用动态链接 (dll)来调用别人写好的函数 同一语言可以调用别人写好的静态(lib) 静态链接:是通过静态联编的,在链接时,link将自己的(.obj)二进制文件和别人的lib文件一起共同...
  • 寻找的顺序是:/home/hello/lib–>/lib–>/usr/lib–>/usr/local/lib -lworld表示在上面的lib的路径中寻找libworld.so动态库文件(如果gcc编译选项中加入了“-static”表示寻找libworld.a静态库文件) ——————...
  • 在centos 6.2下用file命令查看文件信息的时候,显示如下: libcom_err.so.2: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, stripped libcrypto.so.10: ELF 64-bit LSB shared ...
  • 假设编译交叉编译工具路径为dir1(arm-linux-androideabi-gcc-4.9 ),存放生成的.so文件的路径为dir2,test.cpp,依赖1.a,2.a,3.a这三个静态文件库,Makefile文件应该怎么写
  • Android 打包so动态库文件到APK

    千次阅读 2014-03-28 16:01:07
    有时由于项目需要使用JNI来调用.so文件,需要将so文件一起打包到APK文件中,这有两种方法:   1. 使用mm命令和Android SDK源代码一起编译。 在project根目录创建一个Android.mk,文件内容如: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,914
精华内容 15,165
关键字:

动态库文件