makefile教程

2021 年 5 月 23 日分類 devops, make

简介

Linux的make程序用来自动化编译大型源码，很多时候，我们在Linux下编译安装软件，只需要敲一个make就可以全自动完成，非常方便。

make能自动化完成这些工作，是因为项目提供了一个Makefile文件，它负责告诉make，应该如何编译和链接程序。

Makefile相当于Java项目的pom.xml，Node工程的package.json，Rust项目的Cargo.toml，不同之处在于，make虽然最初是针对C语言开发，但它实际上并不限定C语言，而是可以应用到任意项目，甚至不是编程语言。此外，make主要用于Unix/Linux环境的自动化开发，掌握Makefile的写法，可以更好地在Linux环境下做开发，也可以为后续开发Linux内核做好准备。

在本教程中，我们将由浅入深，一步一步学习如何编写Makefile，完全针对零基础小白，只需要提前掌握如何使用Linux命令。

在Linux环境下，当我们输入make命令时，它就在当前目录查找一个名为Makefile的文件，然后，根据这个文件定义的规则，自动化地执行任意命令，包括编译命令。

Makefile这个单词，顾名思义，就是指如何生成文件。

我们举个例子：在当前目录下，有3个文本文件：a.txt，b.txt和c.txt。

现在，我们要合并a.txt与b.txt，生成中间文件m.txt，再用中间文件m.txt与c.txt合并，生成最终的目标文件x.txt，整个逻辑如下图所示：

┌─────┐ ┌─────┐ ┌─────┐
│a.txt│ │b.txt│ │c.txt│
└─────┘ └─────┘ └─────┘
   │       │       │
   └───┬───┘       │
       │           │
       ▼           │
    ┌─────┐        │
    │m.txt│        │
    └─────┘        │
       │           │
       └─────┬─────┘
             │
             ▼
          ┌─────┐
          │x.txt│
          └─────┘

根据上述逻辑，我们来编写Makefile。

规则

Makefile由若干条规则（Rule）构成，每一条规则指出一个目标文件（Target），若干依赖文件（prerequisites），以及生成目标文件的命令。

例如，要生成m.txt，依赖a.txt与b.txt，规则如下：

1
2
3

# 目标文件: 依赖文件1 依赖文件2
m.txt: a.txt b.txt
	cat a.txt b.txt > m.txt

一条规则的格式为目标文件: 依赖文件1 依赖文件2 ...，紧接着，以Tab开头的是命令，用来生成目标文件。上述规则使用cat命令合并了a.txt与b.txt，并写入到m.txt。用什么方式生成目标文件make并不关心，因为命令完全是我们自己写的，可以是编译命令，也可以是cp、mv等任何命令。

以#开头的是注释，会被make命令忽略。

1	注意：Makefile的规则中，命令必须以Tab开头，不能是空格。

类似的，我们写出生成x.txt的规则如下：

1 2	x.txt: m.txt c.txt cat m.txt c.txt > x.txt

由于make执行时，默认执行第一条规则，所以，我们把规则x.txt放到前面。完整的Makefile如下：

x.txt: m.txt c.txt
	cat m.txt c.txt > x.txt

m.txt: a.txt b.txt
	cat a.txt b.txt > m.txt

在当前目录创建a.txt、b.txt和c.txt，输入一些内容，执行make：

1
2
3

$ make
cat a.txt b.txt > m.txt
cat m.txt c.txt > x.txt

make默认执行第一条规则，也就是创建x.txt，但是由于x.txt依赖的文件m.txt不存在（另一个依赖c.txt已存在），故需要先执行规则m.txt创建出m.txt文件，再执行规则x.txt。执行完成后，当前目录下生成了两个文件m.txt和x.txt。

可见，Makefile定义了一系列规则，每个规则在满足依赖文件的前提下执行命令，就能创建出一个目标文件，这就是英文Make file的意思。

把默认执行的规则放第一条，其他规则的顺序是无关紧要的，因为make执行时自动判断依赖。

此外，make会打印出执行的每一条命令，便于我们观察执行顺序以便调试。

如果我们再次运行make，输出如下：

1 2	$ make make: `x.txt' is up to date.

make检测到x.txt已经是最新版本，无需再次执行，因为x.txt的创建时间晚于它依赖的m.txt和c.txt的最后修改时间。

1	make使用文件的创建和修改时间来判断是否应该更新一个目标文件。

修改c.txt后，运行make，会触发x.txt的更新：

1 2	$ make cat m.txt c.txt > x.txt

但并不会触发m.txt的更新，原因是m.txt的依赖a.txt与b.txt并未更新，所以，make只会根据Makefile去执行那些必要的规则，并不会把所有规则都无脑执行一遍。

在编译大型程序时，全量编译往往需要几十分钟甚至几个小时。全量编译完成后，如果仅修改了几个文件，再全部重新编译完全没有必要，用Makefile实现增量编译就十分节省时间。

当然，是否能正确地实现增量更新，取决于我们的规则写得对不对，make本身并不会检查规则逻辑是否正确。

伪目标

因为m.txt与x.txt都是自动生成的文件，所以，可以安全地删除。

删除时，我们也不希望手动删除，而是编写一个clean规则来删除它们：

1
2
3

clean:
	rm -f m.txt
	rm -f x.txt

clean规则与我们前面编写的规则有所不同，它没有依赖文件，因此，要执行clean，必须用命令make clean：

1
2
3

$ make clean
rm -f m.txt
rm -f x.txt

然而，在执行clean时，我们并没有创建一个名为clean的文件，所以，因为目标文件clean不存在，每次运行make clean，都会执行这个规则的命令。

如果我们手动创建一个clean的文件，这个clean规则就不会执行了！

如果我们希望make把clean不要视为文件，可以添加一个标识：

.PHONY: clean
clean:
	rm -f m.txt
	rm -f x.txt

此时，clean就不被视为一个文件，而是伪目标（Phony Target）。

大型项目通常会提供clean、install这些约定俗成的伪目标名称，方便用户快速执行特定任务。

一般来说，并不需要用.PHONY标识clean等约定俗成的伪目标名称，除非有人故意搞破坏，手动创建名字叫clean的文件。

执行多条命令

一个规则可以有多条命令，例如：

cd:
	pwd
	cd ..
	pwd

执行cd规则：

$ make cd
pwd
/home/ubuntu/makefile-tutorial/v1
cd ..
pwd
/home/ubuntu/makefile-tutorial/v1

观察输出，发现cd ..命令执行后，并未改变当前目录，两次输出的pwd是一样的，这是因为make针对每条命令，都会创建一个独立的Shell环境，类似cd ..这样的命令，并不会影响当前目录。

解决办法是把多条命令以;分隔，写到一行：

1 2	cd_ok: pwd; cd ..; pwd;

再执行cd_ok目标就得到了预期结果：

$ make cd_ok
pwd; cd ..; pwd
/home/ubuntu/makefile-tutorial/v1
/home/ubuntu/makefile-tutorial

可以使用\把一行语句拆成多行，便于浏览：

cd_ok:
	pwd; \
	cd ..; \
	pwd

另一种执行多条命令的语法是用&&，它的好处是当某条命令失败时，后续命令不会继续执行：

1 2	cd_ok: cd .. && pwd

控制打印

默认情况下，make会打印出它执行的每一条命令。如果我们不想打印某一条命令，可以在命令前加上@，表示不打印命令（但是仍然会执行）：

1
2
3

no_output:
	@echo 'not display'
	echo 'will display'

执行结果如下：

$ make no_output
not display
echo 'will display'
will display

注意命令echo 'not display'本身没有打印，但命令仍然会执行，并且执行的结果仍然正常打印。

控制错误

make在执行命令时，会检查每一条命令的返回值，如果返回错误（非0值），就会中断执行。

例如，不使用-f删除一个不存在的文件会报错：

1
2
3

has_error:
	rm zzz.txt
	echo 'ok'

执行上述目标，输出如下：

$ make has_error
rm zzz.txt
rm: zzz.txt: No such file or directory
make: *** [has_error] Error 1

由于命令rm zzz.txt报错，导致后面的命令echo 'ok'并不会执行，make打印出错误，然后退出。

有些时候，我们想忽略错误，继续执行后续命令，可以在需要忽略错误的命令前加上-：

1
2
3

ignore_error:
	-rm zzz.txt
	echo 'ok'

执行上述目标，输出如下：

$ make ignore_error
rm zzz.txt
rm: zzz.txt: No such file or directory
make: [ignore_error] Error 1 (ignored)
echo 'ok'
ok

make检测到rm zzz.txt报错，并打印错误，但显示(ignored)，然后继续执行后续命令。

对于执行可能出错，但不影响逻辑的命令，可以用-忽略。

参考源码

可以从GitHub下载源码。

小结

编写Makefile就是编写一系列规则，用来告诉make如何执行这些规则，最终生成我们期望的目标文件。

查看官方手册：

编译C程序

C程序的编译通常分两步：

将每个.c文件编译为.o文件；
将所有.o文件链接为最终的可执行文件。

我们假设如下的一个C项目，包含hello.c、hello.h和main.c。

hello.c内容如下：

#include <stdio.h>

int hello()
{
    printf("hello, world!\n");
    return 0;
}

hello.h内容如下：

1	int hello();

main.c内容如下：

#include <stdio.h>
#include "hello.h"

int main()
{
    printf("start...\n");
    hello();
    printf("exit.\n");
    return 0;
}

注意到main.c引用了头文件hello.h。我们很容易梳理出需要生成的文件，逻辑如下：

┌───────┐ ┌───────┐ ┌───────┐
│hello.c│ │main.c │ │hello.h│
└───────┘ └───────┘ └───────┘
    │         │         │
    │         └────┬────┘
    │              │
    ▼              ▼
┌───────┐      ┌───────┐
│hello.o│      │main.o │
└───────┘      └───────┘
    │              │
    └───────┬──────┘
            │
            ▼
       ┌─────────┐
       │world.out│
       └─────────┘

假定最终生成的可执行文件是world.out，中间步骤还需要生成hello.o和main.o两个文件。根据上述依赖关系，我们可以很容易地写出Makefile如下：

# 生成可执行文件:
world.out: hello.o main.o
	cc -o world.out hello.o main.o

# 编译 hello.c:
hello.o: hello.c
	cc -c hello.c

# 编译 main.c:
main.o: main.c hello.h
	cc -c main.c

clean:
	rm -f *.o world.out

执行make，输出如下：

$ make
cc -c hello.c
cc -c main.c
cc -o world.out hello.o main.o

在当前目录下可以看到hello.o、main.o以及最终的可执行程序world.out。执行world.out：

$ ./world.out 
start...
hello, world!
exit.

与我们预期相符。

修改hello.c，把输出改为"hello, bob!\n"，再执行make，观察输出：

1
2
3

$ make
cc -c hello.c
cc -o world.out hello.o main.o

仅重新编译了hello.c，并未编译main.c。由于hello.o已更新，所以，仍然要重新生成world.out。执行world.out：

$ ./world.out 
start...
hello, bob!
exit.

与我们预期相符。

修改hello.h：

1 2	// int 变为 void: void hello();

以及hello.c，再次执行make：

$ make
cc -c hello.c
cc -c main.c
cc -o world.out hello.o main.o

会触发main.c的编译，因为main.c依赖hello.h。

执行make clean会删除所有的.o文件，以及可执行文件world.out，再次执行make就会强制全量编译：

$ make clean && make
rm -f *.o world.out
cc -c hello.c
cc -c main.c
cc -o world.out hello.o main.o

这个简单的Makefile使我们能自动化编译C程序，十分方便。

不过，随着越来越多的.c文件被添加进来，如何高效维护Makefile的规则？我们后面继续讲解。

参考源码

可以从GitHub下载源码。

小结

在Makefile正确定义规则后，我们就能用make自动化编译C程序。

使用隐式规则

我们仍然以上一节的C项目为例，当我们添加越来越多的.c文件时，就需要编写越来越多的规则来生成.o文件。

实际上，有的同学可能发现了，即使我们把.o的规则删掉，也能正常编译：

# 只保留生成 world.out 的规则:
world.out: hello.o main.o
	cc -o world.out hello.o main.o

clean:
	rm -f *.o world.out

执行make，输出如下：

$ make
cc    -c -o hello.o hello.c
cc    -c -o main.o main.c
cc -o world.out hello.o main.o

我们没有定义hello.o和main.o的规则，为什么make也能正常创建这两个文件？

因为make最初就是为了编译C程序而设计的，为了免去重复创建编译.o文件的规则，make内置了隐式规则（Implicit Rule），即遇到一个xyz.o时，如果没有找到对应的规则，就自动应用一个隐式规则：

1 2	xyz.o: xyz.c cc -c -o xyz.o xyz.c

make针对C、C++、ASM、Fortran等程序内置了一系列隐式规则，可以参考官方手册查看。

对于C程序来说，使用隐式规则有一个潜在问题，那就是无法跟踪.h文件的修改。如果我们修改了hello.h的定义，由于隐式规则main.o: main.c并不会跟踪hello.h的修改，导致main.c不会被重新编译，这个问题我们放到后面解决。

参考源码

可以从GitHub下载源码。

小结

针对C、C++、ASM、Fortran等程序，make内置了一系列隐式规则，使用隐式规则可减少大量重复的通用编译规则。

查看官方手册：

使用隐式规则

当我们在Makefile中重复写很多文件名时，一来容易写错，二来如果要改名，要全部替换，费时费力。

编程语言使用变量（Variable）来解决反复引用的问题，类似的，在Makefile中，也可以使用变量来解决重复问题。

以上一节的Makefile为例：

world.out: hello.o main.o
	cc -o world.out hello.o main.o

clean:
	rm -f *.o world.out

编译的最终文件world.out重复出现了3次，因此，完全可以定义一个变量来替换它：

TARGET = world.out

$(TARGET): hello.o main.o
	cc -o $(TARGET) hello.o main.o

clean:
	rm -f *.o $(TARGET)

变量定义用变量名 = 值或者变量名 := 值，通常变量名全大写。引用变量用$(变量名)，非常简单。

注意到hello.o main.o这个“列表”也重复了，我们也可以用变量来替换：

OBJS = hello.o main.o
TARGET = world.out

$(TARGET): $(OBJS)
	cc -o $(TARGET) $(OBJS)

clean:
	rm -f *.o $(TARGET)

如果有一种方式能让make自动生成hello.o main.o这个“列表”，就更好了。注意到每个.o文件是由对应的.c文件编译产生的，因此，可以让make先获取.c文件列表，再替换，得到.o文件列表：

# $(wildcard *.c) 列出当前目录下的所有 .c 文件: hello.c main.c
# 用函数 patsubst 进行模式替换得到: hello.o main.o
OBJS = $(patsubst %.c,%.o,$(wildcard *.c))
TARGET = world.out

$(TARGET): $(OBJS)
	cc -o $(TARGET) $(OBJS)

clean:
	rm -f *.o $(TARGET)

这样，我们每添加一个.c文件，不需要修改Makefile，变量OBJS会自动更新。

思考：为什么我们不能直接定义OBJS = $(wildcard *.o)让make列出所有.o文件？

内置变量

我们还可以用变量$(CC)替换命令cc：

1 2	$(TARGET): $(OBJS) $(CC) -o $(TARGET) $(OBJS)

没有定义变量CC也可以引用它，因为它是make的内置变量（Builtin Variables），表示C编译器的名字，默认值是cc，我们也可以修改它，例如使用交叉编译时，指定编译器：

1 2	CC = riscv64-linux-gnu-gcc ...

自动变量

在Makefile中，经常可以看到$@、$<这样的变量，这种变量称为自动变量（Automatic Variable），它们在一个规则中自动指向某个值。

例如，$@表示目标文件，$^表示所有依赖文件，因此，我们可以这么写：

1 2	world.out: hello.o main.o cc -o $@ $^

在没有歧义时可以写$@，也可以写$(@)，有歧义时必须用括号，例如$(@D)。

为了更好地调试，我们还可以把变量打印出来：

world.out: hello.o main.o
	@echo '$$@ = $@' # 变量 $@ 表示target
	@echo '$$< = $<' # 变量 $< 表示第一个依赖项
	@echo '$$^ = $^' # 变量 $^ 表示所有依赖项
	cc -o $@ $^

执行结果输出如下：

$@ = world.out
$< = hello.o
$^ = hello.o main.o
cc -o world.out hello.o main.o

参考源码

可以从GitHub下载源码。

小结

使用变量可以让Makefile更加容易维护。

查看官方手册：

使用模式规则

前面我们讲了使用隐式规则可以让make在必要时自动创建.o文件的规则，但make的隐式规则的命令是固定的，对于xyz.o: xyz.c，它实际上是：

1	$(CC) $(CFLAGS) -c -o $@ $<

能修改的只有变量$(CC)和$(CFLAGS)。如果要执行多条命令，使用隐式规则就不行了。

这时，我们可以自定义模式规则（Pattern Rules），它允许make匹配模式规则，如果匹配上了，就自动创建一条模式规则。

我们修改上一节的Makefile如下：

OBJS = $(patsubst %.c,%.o,$(wildcard *.c))
TARGET = world.out

$(TARGET): $(OBJS)
	cc -o $(TARGET) $(OBJS)

# 模式匹配规则：当make需要目标 xyz.o 时，自动生成一条 xyz.o: xyz.c 规则:
%.o: %.c
	@echo 'compiling $<...'
	cc -c -o $@ $<

clean:
	rm -f *.o $(TARGET)

当make执行world.out: hello.o main.o时，发现没有hello.o文件，于是需要查找以hello.o为目标的规则，结果匹配到模式规则%.o: %.c，于是make自动根据模式规则为我们动态创建了如下规则：

1
2
3

hello.o: hello.c
	@echo 'compiling $<...'
	cc -c -o $@ $<

查找main.o也是类似的匹配过程，于是我们执行make，就可以用模式规则完成编译：

$ make
compiling hello.c...
cc -c -o hello.o hello.c
compiling main.c...
cc -c -o main.o main.c
cc -o world.out hello.o main.o

模式规则的命令完全由我们自己定义，因此，它比隐式规则更灵活。

但是，模式规则仍然没有解决修改hello.h头文件不会触发main.c重新编译的问题，这个依赖问题我们继续放到后面解决。

最后注意，模式规则是按需生成，如果我们在当前目录创建一个zzz.o文件，因为make并不会在执行过程中用到它，所以并不会自动生成zzz.o: zzz.c这个规则。

参考源码

可以从GitHub下载源码。

小结

使用模式规则可以灵活地按需动态创建规则，它比隐式规则更灵活。

查看官方手册：

模式规则

前面我们讲了隐式规则和模式规则，这两种规则都可以解决自动把.c文件编译成.o文件，但都无法解决.c文件依赖.h文件的问题。

因为一个.c文件依赖哪个.h文件必须要分析文件内容才能确定，没有一个简单的文件名映射规则。

但是，要识别出.c文件的头文件依赖，可以用GCC提供的-MM参数：

1 2	$ cc -MM main.c main.o: main.c hello.h

上述输出告诉我们，编译main.o依赖main.c和hello.h两个文件。

因此，我们可以利用GCC的这个功能，对每个.c文件都生成一个依赖项，通常我们把它保存到.d文件中，再用include引入到Makefile，就相当于自动化完成了每个.c文件的精准依赖。

我们改写上一节的Makefile如下：

# 列出所有 .c 文件:
SRCS = $(wildcard *.c)

# 根据SRCS生成 .o 文件列表:
OBJS = $(SRCS:.c=.o)

# 根据SRCS生成 .d 文件列表:
DEPS = $(SRCS:.c=.d)

TARGET = world.out

# 默认目标:
$(TARGET): $(OBJS)
	$(CC) -o $@ $^

# xyz.d 的规则由 xyz.c 生成:
%.d: %.c
	rm -f $@; \
	$(CC) -MM $< >$@.tmp; \
	sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.tmp > $@; \
	rm -f $@.tmp

# 模式规则:
%.o: %.c
	$(CC) -c -o $@ $<

clean:
	rm -rf *.o *.d $(TARGET)

# 引入所有 .d 文件:
include $(DEPS)

变量$(SRCS)通过扫描目录可以确定为hello.c main.c，因此，变量$(OBJS)赋值为hello.o main.o，变量$(DEPS)赋值为hello.d main.d。

通过include $(DEPS)我们引入hello.d和main.d文件，但是这两个文件一开始并不存在，不过，make通过模式规则匹配到%.d: %.c，这就给了我们一个机会，在这个模式规则内部，用cc -MM命令外加sed把.d文件创建出来。

运行make，首次输出如下：

$ make
Makefile:31: hello.d: No such file or directory
Makefile:31: main.d: No such file or directory
rm -f main.d; \
        cc -MM main.c >main.d.tmp; \
        sed 's,\(main\)\.o[ :]*,\1.o main.d : ,g' < main.d.tmp > main.d; \
        rm -f main.d.tmp
rm -f hello.d; \
        cc -MM hello.c >hello.d.tmp; \
        sed 's,\(hello\)\.o[ :]*,\1.o hello.d : ,g' < hello.d.tmp > hello.d; \
        rm -f hello.d.tmp
cc -c -o hello.o hello.c
cc -c -o main.o main.c
cc -o world.out hello.o main.o

make会提示找不到hello.d和main.d，不过随后自动创建出hello.d和main.d。hello.d内容如下：

1	hello.o hello.d : hello.c

上述规则有两个目标文件，实际上相当于如下两条规则：

1 2	hello.o : hello.c hello.d : hello.c

main.d内容如下：

1	main.o main.d : main.c hello.h

因此，main.o依赖于main.c和hello.h，这个依赖关系就和我们手动指定的一致。

改动hello.h，再次运行make，可以触发main.c的编译：

$ make
rm -f main.d; \
        cc -MM main.c >main.d.tmp; \
        sed 's,\(main\)\.o[ :]*,\1.o main.d : ,g' < main.d.tmp > main.d; \
        rm -f main.d.tmp
cc -c -o main.o main.c
cc -o world.out hello.o main.o

在实际项目中，对每个.c文件都可以生成一个对应的.d文件表示依赖关系，再通过include引入到Makefile，同时又能让make自动更新.d文件，有点蛋生鸡和鸡生蛋的关系，不过，这种机制能正常工作，除了.d文件不存在时会打印错误，有强迫症的同学肯定感觉不满意，这个问题我们后面解决。

参考源码

可以从GitHub下载源码。

小结

利用GCC生成.d文件，再用include引入Makefile，可解决一个.c文件应该如何正确触发编译的问题。

查看官方手册：

自动生成依赖

完善Makefile

上一节我们解决了自动生成依赖的问题，这一节我们对项目目录进行整理，把所有源码放入src目录，所有编译生成的文件放入build目录：

<project>
├── Makefile
├── build
└── src
    ├── hello.c
    ├── hello.h
    └── main.c

整理Makefile，内容如下：

SRC_DIR = ./src
BUILD_DIR = ./build
TARGET = $(BUILD_DIR)/world.out

CC = cc
CFLAGS = -Wall

# ./src/*.c
SRCS = $(shell find $(SRC_DIR) -name '*.c')
# ./src/*.c => ./build/*.o
OBJS = $(patsubst $(SRC_DIR)/%.c,$(BUILD_DIR)/%.o,$(SRCS))
# ./src/*.c => ./build/*.d
DEPS = $(patsubst $(SRC_DIR)/%.c,$(BUILD_DIR)/%.d,$(SRCS))

# 默认目标:
all: $(TARGET)

# build/xyz.d 的规则由 src/xyz.c 生成:
$(BUILD_DIR)/%.d: $(SRC_DIR)/%.c
	@mkdir -p $(dir $@); \
	rm -f $@; \
	$(CC) -MM $< >$@.tmp; \
	sed 's,\($*\)\.o[ :]*,$(BUILD_DIR)/\1.o $@ : ,g' < $@.tmp > $@; \
	rm -f $@.tmp

# build/xyz.o 的规则由 src/xyz.c 生成:
$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c
	@mkdir -p $(dir $@)
	$(CC) $(CFLAGS) -c -o $@ $<

# 链接:
$(TARGET): $(OBJS)
	@echo "buiding $@..."
	@mkdir -p $(dir $@)
	$(CC) -o $(TARGET) $(OBJS)

# 清理 build 目录:
clean:
	@echo "clean..."
	rm -rf $(BUILD_DIR)

# 引入所有 .d 文件:
-include $(DEPS)

这个Makefile定义了源码目录SRC_DIR、生成目录BUILD_DIR，以及其他变量，同时用-include消除了.d文件不存在的错误。执行make，输出如下：

$ make
cc -Wall -c -o build/hello.o src/hello.c
cc -Wall -c -o build/main.o src/main.c
buiding build/world.out...
cc -o ./build/world.out ./build/hello.o ./build/main.o

可以说基本满足编译需求，收工！

参考源码

可以从GitHub下载源码。

小结

除了基础的用法外，Makefile还支持条件判断，环境变量，嵌套执行，变量展开等各种功能，需要用到时可以查询官方手册。

留言與分享

makefile教程

简介

规则

伪目标

执行多条命令

控制打印

控制错误

参考源码

小结

编译C程序

参考源码

小结

使用隐式规则

参考源码

小结

内置变量

自动变量

参考源码

小结

使用模式规则

参考源码

小结

参考源码

小结

完善Makefile

参考源码

小结

Kein Chan

R语言-环境安装

R语言-基础

R语言-读取数据

R语言-绘图

R语言-线性回归

1. 算法在计算中的作用

2. 算法基础

3. 函数的增长

4. 分治策略

5. 概率分析和随机算法