精华内容
下载资源
问答
  • makefile编译静态库
    2022-07-20 11:06:57

    如图为当前目录
    在这里插入图片描述
    需要编写一个makefile,将cpp文件编译成静态库,存到lib路径下,然后编译测试文件:

    CXX = g++
    AR = ar -rcs
    
    LIB_DIR = lib
    
    INCLUDE = -Iinclude
    LIB_PATH = -L./lib
    LIBS = -lHyLog
    
    SRCS_CPP = $(wildcard ./HyLog.cpp)
    SRCS = $(notdir $(SRCS_CPP))
    OBJS = $(patsubst %.cpp, $(COMPILE_DIR)/%.o, $(SRCS))
    DEP = $(patsubst %.cpp, $(COMPILE_DIR)/%.cpp.d, $(SRCS))
    
    LIB_NAME=libHyLog.a
    TARGET=$(LIB_DIR)/$(LIB_NAME)
    
    all:$(TARGET)
    
    $(TARGET): $(OBJS)
    	$(AR) $@ $^
     
    $(COMPILE_DIR)/%.o: ./%.cpp $(COMPILE_DIR)/%.cpp.d
    	$(CXX) $(CFLAGS) $(INCLUDE) -c $< -o $@
     
    $(COMPILE_DIR)/%.cpp.d: ./%.cpp
    	$(CXX) $(CFLAGS) $(INCLUDE) -MM -E -c $< -o $@
    	@sed 's/.*\.o/$(subst /,\/,$(dir $@))&/g' $@ > $@.tmp
    	@mv $@.tmp $@
     
    .PHONY: clean
    
    test:
    	$(CXX) testmain.cpp $(LIB_PATH) $(LIBS)  $(INCLUDE) -o test
    
    clean:
    	rm -rf $(LIB_DIR)/$(LIB_NAME)
    	rm -rf test;
    

    参考文章:https://blog.csdn.net/tianyexing2008/article/details/124737771
    END。

    更多相关内容
  • makefile编译静态库与动态库

    千次阅读 2019-03-17 23:40:13
    在大型的项目中,一个工程中的源文件不计数,...1.编译静态库 bin :存放可执行文件 build:存放编译生产的二进制文件(xx.o) include:存放程序编译时需要调用的头文件(xx.h) lib:存放程序链接时(生成可执行...

    在大型的项目中,一个工程中的源文件不计数,其按类型、功能、模块分别放在若干个目录中。为了方便调用其他文件夹中的文件,最通用的方法就是将一些文件编译成静态的库或动态库,这样在包含其他文件夹的头文件时可以更加简便。
    1.编译静态库与动态库
    原目录结构:

    bin :存放可执行文件
    build:存放编译生产的二进制文件(xx.o)
    include:存放程序编译时需要调用的头文件(xx.h)
    lib:存放程序链接时(生成可执行文件)依赖的静态库或动态库
    source:主要存放需要生成静态库和动态库的(*.cpp *.h)文件

    本例子是将test.cpp 生成静态库(libtest.a)和动态库(libtest.so)
    它们是由source中的makefile自动生成的,其中test.cpp的路径为/home/xqs/testlib,下面看makefile:

      1 LIB_NAME ?= test
      2 
      3 PWD :=/home/xqs/testlib
      4 BUILD_PATH := $(PWD)/build
      5 STATIC_NAME ?= lib$(LIB_NAME).a
      6 SHARE_NAME  ?= lib$(LIB_NAME).so
      7 
      8 TARGET_PATH := $(PWD)/lib
      9 STATIC_TARGET := $(TARGET_PATH)/$(STATIC_NAME)
     10 SHARE_TARGET := $(TARGET_PATH)/$(SHARE_NAME)
     11 
     12 SOURCE :=$(wildcard *.cpp)
     13 OBJS := $(patsubst %.cpp, $(BUILD_PATH)/%.o, $(wildcard *.cpp)) 
     14 
     15 all:$(STATIC_TARGET) $(SHARE_TARGET)
     16 
     17 #生成静态库 libtest.a
     18 $(STATIC_TARGET):$(OBJS) 
     19     ar cru $(STATIC_TARGET) $(OBJS) 
     20     ranlib $(STATIC_TARGET)
     21 
     22 #生成动态库 libtest.so
     23 $(SHARE_TARGET):$(OBJS)
     24     $(CXX) -shared -fPIC -o $(SHARE_TARGET) $(SOURCE)
     25 
     26 #生成二进制文件(*.o)                                                                                                                                                                     
     27 $(OBJS): $(wildcard *.cpp)
     28     $(CXX) -c $< -o $@
     29 
     30 clean:
     31     rm -rf $(BUILD_PATH)/*.o $(TARGET_PATH)/*.{a,so}
     32 
     33 .PHONY: all clean
    

    make 之后:testlib文件夹的目录结构为:
    在这里插入图片描述
    从上图可以看到:test.o文件在build,libtest.a与libtest.so在lib中

    2.外层makefile:生成可执行文件

      1 EXE ?= test
      2 
      3 PWD :=/home/xqs/testlib/bin
      4 SHARE_EXE  ?= share_$(EXE)
      5 STATIC_EXE ?= static_$(EXE)
      6  
      7 STATIC_TARGET := $(PWD)/$(STATIC_EXE)
      8 SHARE_TARGET := $(PWD)/$(SHARE_EXE)                                                                                                                                                      
      9 
     10 INCL := -I./include/
     11 LIB  := -L./lib/
     12 LIB_NAME := test
     13 
     14  
     15 all:$(STATIC_TARGET) $(SHARE_TARGET)
     16      
     17 $(STATIC_TARGET): 
     18     $(CXX) main.cpp -o $(STATIC_TARGET) $(INCL) $(LIB) -l$(LIB_NAME) 
     19 
     20 $(SHARE_TARGET):
     21     $(CXX)  main.cpp $(INCL) $(LIB) -l$(LIB_NAME) -o $(SHARE_TARGET)
     22 
     23 static_app: 
     24     $(CXX)  main.cpp $(INCL) $(LIB) -l$(LIB_NAME) -o $(STATIC_EXE)
     25          
     26 shared_app:
     27     $(CXX)  main.cpp $(INCL) $(LIB) -l$(LIB_NAME) -o $(SHARE_EXE)
     28          
     29 clean:
     30     rm -rf $(STATIC_EXE) $(SHARE_EXE)
    

    make 之后,testlib文件夹的结构为:

    在这里插入图片描述
    从上图可以看出:生成的可执行文件在bin文件夹中

    3.链接静态库生成可执行文件static_test
    需要注意的是:当lib库中既有静态库又有动态库时,生成可执行文件static_test时会自动链接动态库libtest.so,这是不对的,所以在生成static_test可执行文件时先移除掉动态库libtset.so。

    4.执行share_test
    在运行可执行文件share_test之前,需要指定动态库的位置,否则会出现找不到库文件的错误:error while loading shared libraries: libtest.so: cannot open shared object file: No such file or directory

    所以可以导入动态库的路径:
    export LD_LIBRARY_PATH=’/home/xqs/testlib/lib/’
    或者 如果不指定库的位置,也可以直接将库放到/lib 或者/usr/lib下

    5.编译时遇到的一些问题:

    • 找不到/usr/bin/ld: cannot find -lc,找不到/usr/bin/ld: cannot find -lm,找不到/usr/bin/ld: cannot find -lstdc++;这主要是由于编译选项中有-static关键字引起的,解决这问题的方法为:

      (1)locate libc.*,找到文件的所在目录,如果有libc.so.1等类似文件,进入文件目录,然后ln -s libc.so.1 libc.so
      (2)如果还报同样的错误,则进入root用户下,yum install glibc-static,安装静态库

    6.编写makefile的一些坑

    1.变量的结尾最好不要有空格,在VIM下可以用shift+$检测是不是最后一个字符是变量的结尾

    源码下载链接:链接:https://pan.baidu.com/s/1KG0IKvbpZlDgIzNDzByTmQ 提取码:sdzr

    展开全文
  • 静态库生成及使用 calc.h #ifndef __MY_LIB_H__ #define __MY_LIB_H__ int add(int a, int b); #endif calc.c #include "calc.h" #include <stdio.h> int sum(int i, int j) { return (i+j); } ...

    静态库生成及使用

    calc.h

    #ifndef __MY_LIB_H__

    #define __MY_LIB_H__

    int add(int a, int b);

    #endif

    calc.c

    #include "calc.h"

    #include <stdio.h>

    int sum(int i, int j)
    {
        return (i+j);
    }

    编译:

    gcc -c calc.c -o calc.o

    ar -cr libcalc.a calc.o

    gcc -o main main.c ./libcalc.a

     

    动态库生成及使用

    show.h

    #ifndef __SHOW_H__
    #define __SHOW_H__

    void show(int i, char* name);

    #endif

    show.c

    #include "show.h"
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>

    void show(int i, char* name)
    {
        printf("%s=%d\n", name, i);

    }

    编译:

    gcc -fPIC -Wall -c show.c -o show.o

    gcc -shared -o libshow.so show.o

    gcc -o main main.c ./libshow.so

    主函数:

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include "../inc/calc.h"
    #include "../inc/show.h"     //可替换makefile的 -I参数添加路径inc

    int main(void)
    {
        int s;
        int i = 1;
        int j = 2;
        s = sum(i,j);
        printf ("%d\n", s);
        show(s,"sum");
        return 0;
    }

     

    注意:

    因为gcc 或者g++时编译会在前者加lib、后者添加.a或者.so,所以有了另一种主函数写法

    cd /etc

    编辑 ld.so.conf 

    sudo vim ld.so.conf

    加入 libshow.so 的路径  /lib

    保存之后 再执行如下命令 ldconfig

     

    gcc -o main main.c  -L. ./lshow -I../inc

    或者指定lib路径

    gcc -o main.o -c main.c -Wall -I../inc
    gcc -o ../bin/main main.o -L../lib -lshow -lcalc

     

     

    Makefile模板

    #-------------------------配置区域-----------------------

    #DIR指的是.o文件和.c文件所在的目录
    DIR=

    #BIN指的是最终生成的目标对象名(包括路径),它可以是可执行程序、动态链接库或静态链接库
    BIN=$(DIR)/

    #SHARE特指链接生成动态链接库对象时的编译选项
    SHARE=--share

    #CFLAG即compile flag,表示在编译时所加入的选项参数
    #参数包括  
    #-Wall  : 编译后显示所有警告信息
    #-g     : 编译时加入调试信息,以便之后可以用gdb调试
    #-fPIC  : 编译动态链接库时加入的选项
    #-I./inc: -I选项指定从哪个目录寻找头文件,在这指定之后,在源文件中包含头文件就可以使用<>,这里./inc即为指定的目录
    CFLAG=

    #LFLAG即library flag,表示链接生成可执行程序时所要链接的所有库的选项参数
    #-L./lib : -L指示动态/静态链接库所在的目录,这里./lib即所在的目录
    #-l      : -l指示动态/静态链接库的名字,注意: 这里的库名字并不包括前缀(lib)和后缀(.a或.so)
    #$(SHARE) : 取SHARE变量对应的动态链接库链接选项--share
    LFLAG=

    #CC即编译链接命令gcc -o 用于编译或者链接动态库以及可执行程序
    CC=gcc -o

    #AR即ar -cr ,ar -cr是专门链接生成静态库的命令
    #-c : 即create,创建静态库
    #-r : 即replace,当静态库改变时,替代原有静态库
    AR=ar -cr

    #最终用的是哪个链接命令
    #链接生成动态库和可执行程序用CC
    #链接生成静态库用AR
    CO=$(CC)


    #-------------------------以下为通用不变区域-----------------------

    #SRC指的是指定目录下的所有.c文件名,OBJ指的是指定目录下的所有.o文件名
    SRC=$(wildcard $(DIR)/*.c)
    OBJ=$(patsubst %.c, %.o, $(SRC))

    #链接命令
    all:$(BIN)
    $(BIN):$(OBJ)
        $(CO) $@ $^ $(LFLAG)

    #编译命令
    $(DIR)/%.o:$(DIR)/%.c
        $(CC) $@ -c $< $(CFLAG)


    #清除无用文件
    .PHONY:clean
    clean:
        rm $(OBJ) $(BIN)

    $@ --目标文件,$^ --所有的依赖文件,$< --第一个依赖文件

    .PHONY :是一个伪目标,可以防止在Makefile中定义的只执行命令的目标和工作目录下的实际文件出现名字冲突,另一种是提交执行makefile时的效率。

    wildcard : 扩展通配符

    notdir : 去除路径

    patsubst :替换通配符

    -I../inc :通用头文件 

     

    整个项目工程都包括什么?

    一个工程目录下一般有7个目录,一个联合编译Makefile文件:

             <1>、bin目录:一般存放可执行程序

             <2>、etc目录:存放配置文件

             <3>、lib目录 :存放所有的库文件,包括动态库和静态库

             <4>、inc目录:存放所有的公共头文件,一般是动态库和静态库对应的头文件

             <5>、src目录:存放项目源码文件和编译它的Makefile文件

             <6>、static目录:存放静态库源文件和编译它的Makefile文件

             <7>、dynamic目录:存放动态库源文件和编译它的Makefile文件

     

    为src、static、dynamic目录下的源文件编写不同的Makefile文件

    为static目录,即静态链接库源代码目录。在此目录下要生成静态链接库文件libstatic_test.a

    #------------------------------配置区域----------------------------

    DIR=.

    #静态库名以lib为前缀,.a为后缀
    BIN=../lib/libcalc.a

    SHARE=--share

    CFLAG=

    LFLAG=

    CC=gcc -o

    AR=ar -cr

    #编译静态库用ar -cr命令
    CO=$(AR)
    #-------------------------以下为通用不变区域-----------------------

    SRC=$(wildcard $(DIR)/*.c)
    OBJ=$(patsubst %.c, %.o, $(SRC))
    #$(info $(OBJ))

    all:$(BIN)
    $(BIN):$(OBJ)
        $(CO) $@ $^ $(LFLAG)

    $(DIR)/%.o:$(DIR)/%.c
        $(CC) $@ -c $< $(CFLAG)

    .PHONY:clean
    clean:
        rm $(OBJ) $(BIN)

     

    为dynamic目录,即动态链接库源代码目录,在此目录下生成动态链接库 libshow.so

    #------------------------------配置区域----------------------------

    DIR=.

    #动态库名以lib为前缀,以.so为后缀
    BIN=../lib/libshow.so

    SHARE=--share

    #动态链接库编译时需要-fPIC选项
    CFLAG=-fPIC

    #链接动态库需要--share选项
    LFLAG=$(SHARE)

    CC=gcc -o

    AR=ar -cr

    #编译动态链接库用gcc -o命令
    CO=$(CC)
    #-------------------------以下为通用不变区域-----------------------

    SRC=$(wildcard $(DIR)/*.c)
    OBJ=$(patsubst %.c, %.o, $(SRC))

    all:$(BIN)
    $(BIN):$(OBJ)
        $(CO) $@ $^ $(LFLAG)

    $(DIR)/%.o:$(DIR)/%.c
        $(CC) $@ -c $< $(CFLAG)

    .PHONY:clean
    clean:
        rm $(OBJ) $(BIN)

     

    为src目录,即工程源代码目录。在此目录下要通过链接动态链接库libshow.so和静态库libcalc.a 来生成可执行文件main

    #-------------------------配置区域-----------------------

    #源码所在的目录
    DIR=.

    #在源码所在目录下生成可执行文件main
    BIN=../bin/main

    SHARE=--share

    #显示所有编译警告,并指示公共头文件(静态库和动态库的头文件)所在目录
    CFLAG= -Wall -I../inc

    #在../lib目录中链接两个外部库文件
    LFLAG=-L../lib -lshow -lcalc

    CC=gcc -o

    AR=ar -cr

    #使用gcc -o 链接命令
    CO=$(CC)


    #-------------------------以下为通用不变区域-----------------------

    #SRC指的是指定目录下的所有.c文件名,OBJ指的是指定目录下的所有.o文件名
    SRC=$(wildcard $(DIR)/*.c)
    OBJ=$(patsubst %.c, %.o, $(SRC))

    #链接命令
    all:$(BIN)
    $(BIN):$(OBJ)
        $(CO) $@ $^ $(LFLAG)

    #编译命令
    $(DIR)/%.o:$(DIR)/%.c
        $(CC) $@ -c $< $(CFLAG)


    #清除无用文件
    .PHONY:clean
    clean:
        rm $(OBJ) $(BIN)

     

    本程序tree

     

    编写联合编译Makefile文件

    .PHONY:test
    test:
        make -C ./dynamic
        #make -C:进入指定的目录下执行make命令
        make -C ./static
        #将静态、动态库文件拷贝到lib目录下
        #cp ./static/libstatic_test.a  ./lib
        #cp ./dynamic/libdynamic_test.so  ./lib
        
        make -C ./src

    .PHONY:install
    install:
        #为lib目录下的动态链接库文件在/usr/lib目录下创建软连接,这里使用的必须是绝对路径
        sudo ln -s /mnt/test/lib/libshow.so  /usr/lib/libshow.so 
        #将最后生成的可执行文件main拷贝到./bin目录下
        #mv ./src/main ./bin

    .PHONY:clean
    clean:
        make clean -C ./dynamic
        #make clean -C: 进入指定目录下执行make clean命令
        make clean -C ./static
        make clean -C ./src

     

    最后得出:

    展开全文
  • ubuntu 使用makefile编译c++静态库

    千次阅读 2020-08-31 19:15:10
    一、编译静态库 1、目录结构: 最终会把编译好的静态库(libmytest.a)放置到lib目录下 2、先确认好库使用声明的.h文件实现,声明两个简单的函数做两个数值的加或减(别在意函数名这细节0.0) ./inclyude/Test.h #...

    学习笔记

    单纯记录在ubuntu使用过程

    使用C++编写一个静态库,头文件与CPP文件分开文件夹放置

    一、编译静态库

    1、目录结构:
    在这里插入图片描述
    最终会把编译好的静态库(libmytest.a)放置到lib目录下

    2、先确认好库使用声明的.h文件实现,声明两个简单的函数做两个数值的加或减(别在意函数名这细节0.0)

    ./inclyude/Test.h
    #ifndef __Test_h
    #define __Test_h
    
    int lib_func_add(int,int);
    int lib_func_del(int,int);
    
    #endif
    
    

    单纯的做一下声明。

    3、将Test.h文件下的两个函数分在两个cpp实现(这个看自己喜欢)

    ./src/lib_add.cpp
    #include "Test.h"
    #include <iostream>
    using namespace std;
    
    int lib_func_add(int a,int b)
    {
            int res = a+b;
            cout<<"in a static library,return value is "<<res<<endl;
            return res;
    }
    
    ./src/lib_del.cpp
    #include "Test.h"
    #include <iostream>
    using namespace std;
    
    int lib_func_del(int a,int b)
    {
            int src = a - b;
            cout<<"in a static library,return value is "<<src<<endl;
            return src;
    }
    
    

    4、代码声明与实现已经准备就绪了,下面就编写makefile文件了。

    关于Makefile介绍

    常见变量:

    all

    这个伪目标是所有目标的目标,其功能一般是编译所有的目标

    clean

    这个伪目标功能是删除所有被make创建的文件

    vpath

    %.h include //指定.h类型文件的搜索路径是include
    %.cpp src //指定.cpp类型文件的搜索路径是src

    CC

    C语言编译程序。默认命令是“cc”

    CXX

    C++语言编译程序。默认命令是“g++”

    CFLAGS

    C语言编译器参数

    CXXFLAGS

    C++语言编译器参数

    INCLUDE

    指明头文件的路径

    LIBPATH

    常用于链接时配合LDFLAGS链接动态库,LIBS指明动态库名称,LDFLAGS指出动态库路径

    LIBVAR

    用于指定连接的lib库文件

    SRCS

    指代项目中的源文件

    OBJS

    指代项目中的目标文件

    TARGET

    指代项目中的可执行文件

    经过以上的介绍,那么就使用这些值把makefile实现。

    makefile
    CC      = gcc
    CFLAGS  = 
    CXXFLAGS= -Wall -O -g
    INCLUDE = -I ./include
    TARGET  = libmytest.a
    LIBPATH = ./lib/
    
    vpath %.h ./include
    vpath %.cpp ./src
    
    OBJS    =lib_add.o lib_del.o
    SRCS    =lib_add.cpp lib_del.cpp
    
    $(OBJS):$(SRCS)
            $(CC) $(CFLAGS) $(INCLUDE) -c $^
    
    all:$(OBJS)
            ar rcs $(TARGET) $^
            mv $(TARGET) $(LIBPATH)
    clear:
            rm -f *.o
            rm -f $(LIBPATH)*
    
    

    -Wall 是打开警告开关,-O代表默认优化,可选:-O0不优化,-O1低级优化,-O2中级优化,-O3高级优化,-Os代码空间优化。
    -g是生成调试信息,生成的可执行文件具有和源代码关联的可调试的信息。

    5、执行make,生成.o文件(可省略此步骤)
    在这里插入图片描述

    6、在执行 make all,生成库文件
    在这里插入图片描述
    在lib目录下生成libmytest.a库文件
    在这里插入图片描述

    7、执行 make clear,清除所有编译文件
    在这里插入图片描述

    二、使用编译好的静态库

    实现在编译好的静态库的基础上使用此库
    1、以下是目录结构,在库目录的上级目录增加main.cpp和makefile文件
    在这里插入图片描述

    2、main.cpp
    #include <iostream>
    #include "Test.h"
    
    using namespace std;
    
    int main()
    {
            int nAdd = 0;
            int nDel = 0;
            nAdd = lib_func_add(1,1);
            nDel = lib_func_del(12,5);
            cout<<"Test lib func_add is Value = "<<nAdd<<endl;
            cout<<"TEst lib func_del is value = "<<nDel<<endl;
            cout<<"Exit main"<<endl;
            return 0;
    }
    
    
    3、makefile
    CC      = gcc
    CFLAGS  =
    CXXFLAGS= -Wall -O -g
    INCLUDE = -I ./Library/include
    TARGET  = main
    LIBVAR  = -lmytest
    LIBPATH = -L ./Library/lib
    
    vpath %.h ./Library/include
    
    OBJS    = main.o
    SRCS    = main.cpp
    
    $(OBJS):$(SRCS)
            $(CC) $(CFLAGS) $(INCLUDE) -c $^
    
    all:$(OBJS)
            cd ./Library && make all
            $(CC) $(CFLAGS) $(INCLUDE) -o main  $(OBJS) $(LIBPATH) $(LIBVAR) -lstdc++
    
    clear:
            rm -f *.o
            rm -f $(TARGET)
            cd ./Library && make clear
    

    注:c++ 编译可执行文件时必须加上-lstdc++ ,不然gcc会默认使用C格式去编辑,导致出错

    其中cd ./Library && make all 和 cd ./Library && make clear 是先执行/Library目录下的make

    4、执行make,生成.o文件(可省略此步骤)
    在这里插入图片描述

    5、在执行 make all,生成可执行文件
    在这里插入图片描述

    可见

    make[1]: Entering directory ‘/home/work/code/TestMakefile/Library’
    gcc -I ./include -c ./src/lib_add.cpp ./src/lib_del.cpp
    ar rcs libmytest.a lib_add.o lib_del.o
    mv libmytest.a ./lib/
    make[1]: Leaving directory ‘/home/work/code/TestMakefile/Library’

    进入/Library目录下执行make all 然后再退出。

    6、输入./main运行可执行文件(可执行文件名称根据自己喜欢修改,在makefile指定的)
    在这里插入图片描述

    一个简单的makefile编译动态库以及使用就这样完成了。

    哈哈!!!

    展开全文
  • 编译json静态库,只是用来作练习,记录一下,供以后查找方便。目录结构如下: 所需头在目录include/json 下,源文件在src目录下,Makefile如下: COMPILE_DIR = compile LIB_DIR = lib #CROSS = arm-himix...
  • Makefile编译静态库.a

    千次阅读 2020-03-18 09:52:57
    Makefile文件所在目录的.c和plat目录下的.c一起编译静态库.a,头文件存放在inc目录下。Makefile文件如下: BIN=libtest.a CC=gcc AR=ar rcs CFLAGS= LIBS= INCS=-I./../inc/ SRCS:=$(wildcard *.c ../plat/*.c)...
  • 使用makefile生成动态库和静态库

    千次阅读 2022-07-30 11:08:20
    1.makefile 2.动态库和静态库 3.shell
  • 使用makefile制作和使用动态库和静态库
  • 一. 编译模板背景: 1. 你有1.c, 2.c,3.c三个源文件 2. 其实你是可以在3.c文件中这样:#include "1...}这样在静态编译库的时候,3.c中的函数可能用到2.c中的函数func2()。这个时候,可以再Makefile中表明,只需要编
  • 静态库编译时会被链接到目标文件中,因此使用静态库编译产生的可执行文件较大。优点是加载速度快,隔离性好。 1.2、makefile制作静态库的方法 ar rcs lib_bcm2835.a $(CUR_OBJS) $(CUR_OBJS)表示生成的.o文件 ...
  • gcc编译动态库静态库及Makefile知识汇总gcc编译静态库,动态库Makefile 基本使用 gcc编译 静态库,动态库 Makefile 基本使用
  • makefile编译静态链接

    千次阅读 2016-11-14 17:33:57
    上面的makefile是子文件夹中的makefile,下面的是外层makefile编译的话外层的目标依赖内层文件夹的静态链接。 上层文件夹中的makefile内容如下: O_FILES = MQTTConnectClient.o \  MQTTConnectServer.o \  ...
  • 本示例演示了需链接动态库静态库,且需要先编译动态库静态库makefile编写方式,makefile文件内部有详细的注释,目录下也有介绍文档,希望大家在遇到这种情况时,把本示例稍作修改,就可以运行起来
  • makefile编译静态库和动态库

    万次阅读 2010-07-19 09:31:00
    静态库 创建静态库  仍使用刚才的hello.c和test.c。  第一步,生成目标文件。  gcc -c hello.c  第二步,把目标文件归档。  ar r libhello.a hello.o  file libhello.a...
  • Make自动化编译工具-编译静态库与动态库 MD Document:2/28/2016 2:23:09 AM by Jiimbowhy CSDN PuBLiSh:http://blog.csdn.net/winsenjiansbomber/article/details/50758180 在软件开发过程中,编译程序有时会成为一...
  • #生成静态库 libtest.a $(STATIC_TARGET):$(OBJS) ar cru $(STATIC_TARGET) $(OBJS) ranlib $(STATIC_TARGET) #生成动态库 libtest.so $(SHARE_TARGET):$(OBJS) $(CXX) -shared -fPIC -o $(SHARE_TARGET) $...
  • makefile编写方法 1.编译执行文件 2.静态库.a文件 3.动态库.so文件
  • makefile链接静态库

    千次阅读 2020-10-21 17:24:10
    } gcc -c add_minus.c 编译生成 add_minus.o ar rc libadd_minus.a add_minus.o 生成静态库 主函数: #include #include"add_minus.h" int main() { printf("hello\n"); printf("%d\n",add(1,2)); printf("%d\n",...
  • 最近要用到的签名算法只给了一堆源码没有给文件,api都不好调用,于是尝试着用Makefile给一堆c源码编译静态链接文件和动态链接文件。Makefile文件编辑的相关资料链接:...
  • 使用Makefile生成静态库

    千次阅读 2020-11-08 20:31:36
    在当前目录下进行make,生成静态库 4.在另一个“.c”中调用这个库 Makefile 1 .PHONY:clean 2 hello:main.o 3 gcc -o $@ $^ -L./ -lmath 4 main.o:main.c 5 gcc -o $@ -c $^ 6 7 clean: 8 rm hello main.o ~ main.c ...
  • 下面小编就为大家带来一篇Linux下g++编译与使用静态库和动态库的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • arithmetic.h:声明...其中all主要生成静态库与动态库相对应的可执行文件,其依赖于静态库与动态库;也就是执行all之前先执行clean, static_lib, shared_lib操作。 gcc –I. main.c -o APP_static –L. -larithme...
  • Makefile学习笔记07|编译静态库并通过ifeq语句   希望看到这篇文章的朋友能在评论区留下宝贵的建议来让我们共同成长,谢谢。   本篇与上一篇有较多联系,有兴趣的可以先看上一篇。 编译静态链接库   xcom这个...
  • 本示例演示了需链接动态库静态库,且需要先编译动态库静态库makefile编写方式,makefile文件内部有详细的注释,目录下也有介绍文档,希望大家在遇到这种情况时,把本示例稍作修改,就可以运行起来
  • gcc MakeFile文件引用静态库与动态库的区别...LIBS += -l库 (这的库是去掉lib,.a, .so剩余部分,如libaaa.so 这写LIBS += -laaa 如libbbb.a 这写LIBS += -lbbb)引用动态库与引用静态库区别,编译没有区别,运行
  • 写了一个编译静态库和动态库的Makefile文件,修改Makefile中STATIC的值可以编译静态库或动态库。MakefileSTATIC=0LIBPATH=libCFLAGS=-WallLDFLAGS=-I$(LIBPATH) -L$(LIBPATH) -lfuncifeq ($(STATIC), 1)LIB=$...
  • Makefile 静态库链接

    千次阅读 2021-09-18 15:44:30
    通过将所有需要被链接的静态库放入 -Xlinker “-(” 与 -Xlinker “-)” 之间,可以是 g++ 链接过程中, 自动循环链接所有静态库,从而解决了原本的链接顺序问题。 2.config.mk # Generated by config_...
  • 本示例演示了编译多个可执行程序,需链接动态库,静态库,且需先编译库,并且库与库之间存在依赖关系的makefile的编写方式,makefile文件内部有详细的注释,目录下也有介绍文档,请务必按照里面的步骤操作,保证可以...
  • 但对于稍微上点规模的应用,其可能会包含若干个模块,复杂点的还会链接其他的动态,这时的makefile可能就不是几行代码就能搞定的了。这时就需要用到一些比较复杂的makefile语法来构建整个应用工程。 如果每次都要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,837
精华内容 15,534
关键字:

makefile编译静态库