Linux应用开发基础知识

2021.09

已于 2023-06-05 10:08:03 修改

阅读量396

点赞数

分类专栏： Linux 文章标签： linux

于 2023-06-01 11:26:35 首次发布

本文链接：https://blog.csdn.net/qq_39240700/article/details/130983764

版权

Linux 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、GCC编译器的使用

1.1 GCC编译过程

执行代码如下：

gcc -E -o hello.i hello.c
gcc -S -o hello.s hello.i
gcc -c -o hello.o hello.s
gcc -o hello hello.o

常用的代码：

以下代码包含了预处理、编译、汇编三个步骤。

gcc -c -o hello.o hello.c // 先编译(不链接)

1.2 怎么编译多个文件

（1）一起编译、链接

gcc -o test main.c sub.c

（2）分开编译，统一链接

gcc -c -o main.o main.c
gcc -c -o sub.o sub.c
gcc -o test main.o sub.o

（3）制作、使用动态库

制作动态库：

gcc -c -o main.o main.c
gcc -c -o sub.o sub.c
gcc -shared -o libsub.so sub.o sub2.o sub3.o(可以使用多个.o 生成动态库)
gcc -o test main.o -lsub -L /libsub.so/所在目录/ --经常为./当前文档
(lsub，是指定libsub.so这个动态库，省略了lib和.so)

运行动态库：

1）先把 libsub.so 放到 Ubuntu 的/lib 目录，然后就可以运行 test 程序

2）如果不想把 libsub.so 放到/lib，也可以放在某个目录比如/a（经常为./当前文档），然后如下执行：

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/a  //添加库的目录

./test

（4）制作、使用静态库

gcc -c -o main.o main.c
gcc -c -o sub.o sub.c
ar crs libsub.a sub.o sub2.o sub3.o(可以使用多个.o 生成静态库)
gcc -o test main.o libsub.a (如果.a 不在当前目录下，需要指定它的绝对或相对路径)

1.3 很有用的选项

gcc -E main.c // 查看预处理结果，比如头文件是哪个
gcc -E -dM main.c > 1.txt // 把所有的宏展开，存在 1.txt 里
gcc -Wp,-MD,abc.dep -c -o main.o main.c // 生成依赖文件 abc.dep，后面 Makefile 会用
echo 'main(){}'| gcc -E -v - // 它会列出头文件目录、库目录(LIBRARY_PATH)

#include <> 为在系统工具链指定的目录去查找头文件
#include “” 为在当前目录查找头文件

二、Makefile的使用

2.1 为什么需要Makefile

Windows系统中有Visual Studio、Keil等编译器，而Linux中没有，Makefile就是对应Linux嵌入式开发中的编译器。

2.2 Makefile的基本规则

Makefile的核心---规则

目标:依赖1 依赖2 ...
[TAB]命令

当“目标文件”不存在，或某个依赖文件比目标文件“新”，则执行“命令”

例子

test:a.o b.o
    gcc -o test a.o b.o
a.o:a.c
    gcc -c -o a.o a.c
b.o:b.c
    gcc -c -o b.o b.c

2.3 Makefile的语法

（1）通配符

%.o ：表示所有的.o文件，%.o可代表a.o、b.o、c.o

%.c ：表示所有的.c文件，%.c可代表a.c、b.c、c.c

$@ ：表示目标

$< : 表示第一个依赖文件

$^ ：表示所有依赖文件

test:a.o b.o c.o
    gcc -o test $^
%.o:%.c
    gcc -c -o $@ $<

（2）假象目标：PHONY

我们想清除文件，我们在上述Makefile的基础上修改为如下代码就可以了：

test:a.o b.o c.o
    gcc -o test $^

%.o:%.c
    gcc -c -o $@ $<

clean:
    rm *.o test  //*.o所有.o文件

执行 make ：生成第一个可执行文件。

执行 make clean : 清除所有文件，即执行： rm *.o test。

make后面可以带上目标名，也可以不带，如果不带目标名的话它就想生成第一个规则里面的第一个目标。

执行：make [目标] 也可以不跟目标名，若无目标默认第一个目标。我们直接执行make的时候，会在makefile里面找到第一个目标然后执行下面的指令生成第一个目标。当我们执行 make clean 的时候，就会在 Makefile 里面找到 clean 这个目标，然后执行里面的命令。

但是这个写法有些问题，原因是我们的目录里面没有 clean 这个文件，这个规则执行的条件成立，他就会执行下面的命令来删除文件。

如果：该目录下面有名为clean文件怎么办呢？

我们在该目录下创建一个名为 “clean” 的文件，然后重新执行：make然后make clean，结果(会有下面的提示：)：

make: \`clean' is up to date.

它根本没有执行我们的删除操作，这是为什么呢？

我们之前说，一个规则能过执行的条件：

*1)目标文件不存在

*2)依赖文件比目标新

现在我们的目录里面有名为“clean”的文件，目标文件是有的，并且没有依赖文件，没有办法判断依赖文件的时间。这种写法会导致：有同名的"clean"文件时，就没有办法执行make clean操作。

解决办法：我们需要把目标定义为假象目标，用关键子PHONY。

.PHONY: clean //把clean定义为假象目标。他就不会判断名为“clean”的文件是否存在，

修改后的代码：

test:a.o b.o c.o
    gcc -o test $^

%.o:%.c
    gcc -c -o $@ $<

clean:
    rm *.o test  //*.o所有.o文件

.PHONY: clean

在原有Makfile的结尾添加.PHONY: clean语句，重新执行：make clean，就会执行删除操作。

（3）变量

1)简单变量(即时变量)：

A := xxx （A的值即刻确定，在定义时即确定）

对于即时变量使用 “:=” 表示，它的值在定义的时候已经被确定了

2）延时变量

B = xxx （B的值使用到时才确定）

对于延时变量使用“=”表示。它只有在使用到的时候才确定，在定义/等于时并没有确定下来。

想使用变量的时候使用“$”来引用，如果不想看到命令是，可以在命令的前面加上"@"符号，就不会显示命令本身。

当我们执行make命令的时候，make这个指令本身，会把整个Makefile读进去，进行全部分析，然后解析里面的变量。

常用的变量的定义如下：

:=  //简单变量（即时变量）


=   //延时变量

?=  //延时变量, 如果是第1次定义才起效, 如果在前面该变量已定义则忽略这句。如果这个变量在前面已经被定义了，这句话就会不会起效果，

+=  //附加, 它是即时变量还是延时变量取决于前面的定义

实例：

A := $(C)
B = $(C)
C = abc

#D = 100ask
D ?= weidongshan

all:
	@echo A = $(A)
	@echo B = $(B)
	@echo D = $(D)

C += 123

执行：

make

结果：

A =
B = abc 123
D = weidongshan

分析：

1）A := $(C)：

A为即使变量，在定义时即确定，由于刚开始C的值为空，所以A的值也为空。

2）B = $(C)：

B为延时变量，只有使用到时它的值才确定，当执行make时，会解析Makefile里面的所用变量，所以先解析C= abc,然后解析C += 123，此时，C = abc 123，当执行：@echo B = $(B)，B的值为 abc 123。

3）D ?= weidongshan：

D变量在前面没有定义，所以D的值为weidongshan，如果在前面添加D = 100ask，最后D的值为100ask。

我们还可以通过命令行存入变量的值例如：

执行：make D=123456 里面的 D ?= weidongshan 这句话就不起作用了，则最后结果为D = 123456。

结果：

A =
B = abc 123
D = 123456

2.4 Makefile的函数

makefile里面可以包含很多函数，这些函数都是make本身实现的，下面我们来几个常用的函数。引用一个函数用“$”。

（1）foreach函数

语法：$(foreach var,list,text)

函数功能：这个函数的工作过程是这样的：如果需要（存在变量或者函数的引用），首先展开变量“VAR”和“LIST”的引用；而表达式“TEXT”中的变量引用不展开。执行时把“LIST”中使用空格分割的单词依次取出赋值给变量“VAR”，然后执行“TEXT”表达式。重复直到“LIST”的最后一个单词（为空时结束）。“TEXT”中的变量或者函数引用在执行时才被展开，因此如果在“TEXT”中存在对“VAR”的引用，那么“VAR”的值在每一次展开式将会到的不同的值。

返回值：空格分割的多次表达式“TEXT”的计算的结果。

我们来看一个例子，定义变量“files”，它的值为四个目录（变量“dirs”代表的a、b、c、d四个目录）下的文件列表：

dirs := a b c d
files := $(foreach dir,$(dirs),$(wildcard $(dir)/*))

例子中，“TEXT”的表达式为“$(wildcard $(dir)/*)”。表达式第一次执行时将展开为“$(wildcard a/*)”；第二次执行时将展开为“$(wildcard b/*)”；第三次展开为“$(wildcard c/*)”；….；以此类推。所以此函数所实现的功能就和一下语句等价：

files := $(wildcard a/* b/* c/* d/*)

再来看一个韦东山视频中的例子：

代码：

A = a b c
B = $(foreach f, $(A), $(f).o)

all:
	@echo B = $(B)

结果：

B = a.o b.o c.o

（2）函数filter/filter-out

函数filter/filter-out语法如下：

$(filter pattern...,text)     # 在text中取出符合patten格式的值
$(filter-out pattern...,text) # 在text中取出不符合patten格式的值

实例：

C = a b c d/

D = $(filter %/, $(C))
E = $(filter-out %/, $(C))

all:
        @echo D = $(D)
        @echo E = $(E)

结果：

D = d/
E = a b c

（3）Wildcard

函数Wildcard语法如下：

$(wildcard pattern) # pattern定义了文件名的格式, wildcard取出其中存在的文件。

这个函数 wildcard 会以 pattern 这个格式，去寻找存在的文件，返回存在文件的名字。

实例：

在该目录下创建三个文件：a.c b.c c.c

files = $(wildcard *.c)

all:
        @echo files = $(files)

结果：

files = a.c b.c c.c

我们也可以用wildcard函数来判断，真实存在的文件

实例：

files2 = a.c b.c c.c d.c e.c  abc
files3 = $(wildcard $(files2))

all:
        @echo files3 = $(files3)

结果：

files3 = a.c b.c c.c

（4）patsubst函数

函数 patsubst 语法如下：

$(patsubst pattern,replacement,$(var))

patsubst 函数是从 var 变量里面取出每一个值，如果这个符合 pattern 格式，把它替换成 replacement 格式。

实例：

files2  = a.c b.c c.c d.c e.c abc

dep_files = $(patsubst %.c,%.d,$(files2))

all:
        @echo dep_files = $(dep_files)

结果：

dep_files = a.d b.d c.d d.d e.d abc

2.5 Makefile实例

原来的Makefile程序存在一个问题：修改".h"文件生成的.o不会更新，生成的应用程序test也不会更新。

为了解决这个问题，修改为了以下程序：

objs = a.o b.o c.o

dep_files := $(patsubst %,.%.d, $(objs))
dep_files := $(wildcard $(dep_files))

CFLAGS = -Werror -Iinclude

test: $(objs)
        gcc -o test $^

ifneq ($(dep_files),)
include $(dep_files)
endif

%.o : %.c
        gcc $(CFLAGS) -c -o $@ $< -MD -MF .$@.d

clean:
        rm *.o test

distclean:
        rm $(dep_files)

.PHONY: clean

其中ifneq函数语法：

比较参数“arg1”和“arg2”的值是否相同。如果不同，则为真。

ifneq (<arg1>;, <arg2>;)

CFLAGS，即编译参数。比如加上编译参数-Werror，把所有的警告当成错误。

除了编译参数-Werror，还可以加上-I参数，指定头文件路径，-Iinclude表示当前程序路径下的inclue文件夹下。此时就可以把c.c文件里的#include ".h"改为#include <c.h>，前者表示当前目录，后者表示编译器指定的路径和GCC路径。这样，编译器就会在include文件夹和GCC路径下搜索头文件。

程序思路：

首先用obj变量将.o文件放在一块。

利用前面讲到的函数，把obj里所有文件都变为.%.d格式，并用变量dep_files表示。

利用前面介绍的wildcard函数，判断dep_files是否存在。若依赖文件.d不存在，就不用包含。

然后是目标文件test依赖所有的.o文件。

如果dep_files变量不为空，就将其包含进来。

然后就是所有的.o文件都依赖.c文件，且通过-MD -MF生成.d依赖文件。

清理所有的.o文件和目标文件。

清理依赖.d文件。

现在我门修改了任何.h文件，最终都会影响最后生成的文件，也没任何手工添加.h、.c、.o文件，完成了支持头文件依赖。