autotools：给Linux项目装上“自动导航”的老伙计

小磊z

 关注

阅读 58

08-03 12:00

你刚学C语言，在终端里敲下gcc hello.c -o hello，看着屏幕上跳出的hello world，心里挺美。但当你把代码发给同学，他用的MacOS，你用的Ubuntu，他编译时报错说“找不到stdio.h”；或者你的项目从1个文件变成10个，每次编译都要输一长串gcc main.c foo.c bar.c -o myapp，敲到手指酸；更麻烦的是，你想把代码打包发给别人，还得写个README告诉人家“先装这个库，再改那个路径”——这时候，你就需要认识一个叫“autotools”的老伙计。

一、为什么需要autotools？从“手工作坊”到“标准化工厂”

想象一下，你是个木匠，刚开始做小板凳，一把锯子、一把锤子就能搞定。但当你接到订单要做100个板凳，每个板凳需要4条腿、1个面、2根横档，还要求客户能自己组装（跨平台），你总不能每个板凳都从头量尺寸、锯木头吧？你得做个“模板”：腿多长、面多大、横档怎么钉，都写清楚，客户拿到模板，照着做就行。

autotools就是Linux项目里的“模板工厂”。它的核心任务只有一个：让项目能在不同系统上“一键编译、安装、打包”。无论是Ubuntu、CentOS、MacOS，甚至是Windows（配合MinGW），只要系统装了autotools，开发者就能用同样的命令把你的代码编译成可执行程序。

它解决的具体问题，你可能已经遇到过：

  • 文件多了怎么办？ 10个源文件、5个头文件，手动写gcc命令会疯掉。autotools能自动生成Makefile（编译规则文件），你只需要告诉它“哪些文件要编译”，它就能帮你搞定依赖关系。
  • 系统不一样怎么办？ Linux的/usr/include和MacOS的/System/Library/Frameworks路径不同，有的系统有libm数学库，有的没有。autotools会先“体检”系统（检查编译器、库、头文件是否存在），再生成适合当前系统的编译规则。
  • 依赖库怎么办？ 你的项目用了zlib压缩库，用户系统里没装怎么办？autotools能检查依赖，如果没装就报错提示，甚至自动下载安装（配合其他工具）。
  • 打包分发怎么办？ 你想把代码打成.tar.gz包，让别人下载后能直接编译安装。autotools能生成标准的configure脚本和Makefile，用户只需要./configure && make && make install三步，比装软件还简单。

二、autotools的核心工具：四个“老师傅”搭班子

autotools不是单个工具，而是一套工具链，核心是四个“老师傅”：autoscan、autoconf、automake、aclocal。它们分工明确，像流水线上的工人，一步步把你的“原始代码”变成“可编译的项目”。

1. autoscan：项目“勘探员”

你刚接手一个项目，代码散落在各个目录，autoscan就是第一个冲进去的“勘探员”。它会扫描你的源文件（.c、.h），找哪些函数需要外部库（比如printf需要libc，sqrt需要libm），哪些头文件可能缺失，然后生成一个“勘探报告”——configure.scan文件。

比如你有个简单的项目，目录结构这样：

hello_project/
├── src/
│   ├── main.c
│   └── hello.c
└── include/
    └── hello.h

main.c里调用了hello.c里的print_hello()函数，hello.h声明了这个函数。你在项目根目录运行：

autoscan

autoscan会扫描src/和include/下的文件，生成configure.scan，内容大概是这样（注释已简化）：

# -*- Autoconf -*-
# Process this file with autoconf to produce a configure script.
AC_PREREQ([2.69])
AC_INIT([FULL-PACKAGE-NAME], [VERSION], [BUG-REPORT-ADDRESS])
AC_CONFIG_SRCDIR([src/main.c])
AC_CONFIG_HEADERS([config.h])

# Checks for programs.
AC_PROG_CC

# Checks for libraries.

# Checks for header files.

# Checks for typedefs, structures, and compiler characteristics.

# Checks for library functions.

AC_OUTPUT

这里面有很多以AC_开头的“宏”（autotools里的“文本替换模板”，比如AC_INIT用于初始化项目信息，AC_PROG_CC用于检查C编译器），autoscan已经帮你写好了基础框架，你只需要修改细节。

2. autoconf：“翻译官”把需求变成脚本

configure.scan是“勘探报告”，但还不能直接用。你需要把它改名为configure.ac（autotools的标准配置文件），然后修改里面的项目信息。比如：

# 把AC_INIT里的信息换成你自己的
AC_INIT([hello], [1.0], [your-email@example.com])
# 告诉autoconf，源码根目录是src/main.c（它用来确认项目路径）
AC_CONFIG_SRCDIR([src/main.c])
# 生成config.h文件（这个文件会包含系统相关的宏定义，比如是否支持某个函数）
AC_CONFIG_HEADERS([config.h])

# 检查C编译器是否存在（比如gcc、clang）
AC_PROG_CC

# 检查是否需要数学库（如果你的代码用了sqrt函数）
AC_CHECK_LIB([m], [sqrt])

# 告诉autoconf，要生成Makefile文件（路径是当前目录的Makefile）
AC_OUTPUT([Makefile])

修改好configure.ac后，运行：

autoconf

autoconf会读取configure.ac里的宏，把它们“翻译”成shell脚本——这就是大名鼎鼎的configure脚本。你可以用cat configure看看，会发现里面是几千行shell代码，全是autoconf帮你写的，内容就是检查系统环境（比如“有没有gcc？”“有没有libm？”“stdio.h在不在？”）。

3. automake：“调度员”安排编译任务

现在有了configure脚本，但它还不知道“具体要编译哪些文件”。这时候需要automake出马，它是个“调度员”，你只需要告诉它“项目结构是什么样的”，它就能生成Makefile.in（Makefile的模板），configure脚本会根据系统情况把Makefile.in变成最终的Makefile。

要让automake工作，你需要写两个文件：Makefile.am（根目录）和src/Makefile.am（子目录）。

根目录的Makefile.am很简单，告诉automake“有哪些子目录需要编译”：

# 告诉automake，子目录src里有需要编译的代码
SUBDIRS = src
# 可选：定义要打包的文件（比如README、AUTHORS等）
dist_doc_DATA = README

src/Makefile.am是核心，告诉automake“要编译成什么程序，需要哪些源文件”：

# 定义要生成的可执行程序名（hello）
bin_PROGRAMS = hello
# 定义hello这个程序需要的源文件（main.c、hello.c，头文件hello.h不用写，automake会自动识别）
hello_SOURCES = main.c hello.c
# 可选：定义需要链接的库（如果用了libm，就写-lm）
hello_LDADD = -lm

写好这两个Makefile.am后，运行：

aclocal      # 先收集用到的宏（比如AC_PROG_CC的定义），生成aclocal.m4
automake --add-missing  # 生成Makefile.in，并自动添加缺失的文件（如install-sh、depcomp）

aclocal的作用是“找宏”：configure.ac里用了AC_PROG_CC、AC_CHECK_LIB这些宏，它们的定义可能在系统的/usr/share/aclocal/目录下，aclocal会把它们收集起来，生成aclocal.m4，autoconf和automake需要这个文件才能正确处理宏。

automake --add-missing会生成Makefile.in，如果发现缺少一些标准文件（比如install-sh，用于安装程序），会自动创建空文件（你不需要管它们，automake会搞定）。

4. configure：“体检医生”生成最终编译方案

现在项目根目录下有了configure脚本、Makefile.in（根目录和src/下都有）、aclocal.m4等文件，最后一步是运行configure：

./configure

configure脚本会开始“体检”系统：

  • 检查编译器：checking for gcc... gcc（有gcc）
  • 检查库：checking for sqrt in -lm... yes（有libm）
  • 检查头文件：checking for stdio.h... yes（有stdio.h）
  • 根据Makefile.in生成最终的Makefile（根目录和src/下都会生成）

体检结束后，你会看到config.status文件（记录configure的结果）和config.h文件（包含系统相关的宏定义，比如#define HAVE_LIBM 1表示有libm）。现在，Makefile已经生成好了，里面包含了适合你系统的编译规则，比如：

hello: $(hello_OBJECTS) $(hello_DEPENDENCIES) 
	@rm -f hello
	$(AM_V_CCLD)$(hello_LINK) $(hello_OBJECTS) $(hello_LDADD) $(LIBS)

这行规则的意思是：用hello_LINK（通常是gcc）链接hello_OBJECTS（main.o、hello.o）和hello_LDADD（-lm），生成hello可执行文件。

三、实战：用autotools构建一个“hello world”项目

光说不练假把式，我们从头到尾用autotools构建一个小项目，让你亲身体验“三步编译”的魔力。

第1步：准备项目代码

创建项目目录，写一个简单的“hello world”程序（分两个文件，模拟真实项目结构）：

# 创建项目目录
mkdir hello_project && cd hello_project
# 创建源码目录和头文件目录
mkdir src include
# 写头文件 include/hello.h
cat > include/hello.h << 'EOF'
#ifndef HELLO_H
#define HELLO_H

void print_hello(const char *name);

#endif
EOF
# 写源文件 src/hello.c（实现print_hello函数）
cat > src/hello.c << 'EOF'
#include <stdio.h>
#include "hello.h"

void print_hello(const char *name) {
    printf("Hello, %s! Welcome to autotools.\n", name);
}
EOF
# 写主程序 src/main.c（调用print_hello）
cat > src/main.c << 'EOF'
#include "hello.h"

int main() {
    print_hello("Alice");
    return 0;
}
EOF

现在目录结构是：

hello_project/
├── include/
│   └── hello.h
└── src/
    ├── main.c
    └── hello.c

第2步：用autoscan生成基础配置

在项目根目录运行autoscan，它会扫描源文件，生成configure.scan：

autoscan

查看configure.scan（已简化注释）：

AC_PREREQ([2.69])
AC_INIT([FULL-PACKAGE-NAME], [VERSION], [BUG-REPORT-ADDRESS])
AC_CONFIG_SRCDIR([src/main.c])
AC_CONFIG_HEADERS([config.h])
AC_PROG_CC
AC_OUTPUT

第3步：修改configure.ac

把configure.scan改名为configure.ac，并修改项目信息：

mv configure.scan configure.ac

编辑configure.ac（用vim或nano），修改成这样：

# 初始化项目：名称(hello)、版本(1.0)、邮箱(your-email@example.com)
AC_INIT([hello], [1.0], [your-email@example.com])
# 源码根目录标志文件（autoconf用它确认项目路径）
AC_CONFIG_SRCDIR([src/main.c])
# 生成config.h（包含系统相关的宏定义）
AC_CONFIG_HEADERS([config.h])
# 检查C编译器（比如gcc、clang）
AC_PROG_CC
# 检查标准头文件（比如stdio.h，虽然autoscan没加，但最好加上）
AC_CHECK_HEADERS([stdio.h stdlib.h])
# 告诉autoconf，要生成Makefile（根目录和src/子目录）
AC_OUTPUT([Makefile src/Makefile])

注意AC_OUTPUT里加了src/Makefile，因为我们在src/目录下也要放Makefile。

第4步：写Makefile.am

根目录和src/目录下都要写Makefile.am。

根目录的Makefile.am：

cat > Makefile.am << 'EOF'
# 告诉automake，子目录src需要编译
SUBDIRS = src
# 定义要打包到发行版里的文档（README）
dist_doc_DATA = README
EOF

src/Makefile.am：

cat > src/Makefile.am << 'EOF'
# 定义要生成的可执行程序（安装在/usr/local/bin目录下）
bin_PROGRAMS = hello
# 定义hello程序的源文件（main.c、hello.c）
hello_SOURCES = main.c hello.c
# 告诉automake，头文件在../include目录（编译时需要找hello.h）
AM_CPPFLAGS = -I../include
EOF

AM_CPPFLAGS是给C编译器的预处理器标志，-I../include告诉编译器“去../include目录找头文件”（因为hello.h在include/目录，而src/和include/是平级的）。

第5步：生成configure脚本和Makefile.in

现在运行aclocal、autoconf、automake，生成最终的脚本和模板：

# 收集宏，生成aclocal.m4
aclocal
# 生成configure脚本
autoconf
# 生成Makefile.in，并自动添加缺失文件（如install-sh）
automake --add-missing

运行后，项目根目录下会多出很多文件：

  • configure：可执行的shell脚本（用户运行它来生成Makefile）
  • aclocal.m4：收集的宏定义
  • Makefile.in：根目录的Makefile模板
  • src/Makefile.in：src目录的Makefile模板
  • config.h.in：config.h的模板（由autoheader生成，autoconf会自动调用）
  • install-sh、depcomp等：automake自动添加的辅助脚本（不用管）

第6步：编译、安装、测试

现在万事俱备，只需要“三步曲”：

# 第1步：运行configure，生成Makefile
./configure

你会看到一堆检查信息，最后显示：

config.status: creating Makefile
config.status: creating src/Makefile
config.status: creating config.h

说明Makefile已经生成好了（根目录和src/下都有）。

# 第2步：编译（make会根据Makefile执行gcc命令）
make

输出大概是这样：

Making all in src
gcc -DHAVE_CONFIG_H -I. -I..  -I../include  -g -O2 -MT main.o -MD -MP -MF .deps/main.Tpo -c -o main.o main.c
gcc -DHAVE_CONFIG_H -I. -I..  -I../include  -g -O2 -MT hello.o -MD -MP -MF .deps/hello.Tpo -c -o hello.o hello.c
gcc  -g -O2   -o hello main.o hello.o

src/目录下生成了hello可执行文件！

# 第3步：运行测试
./src/hello

输出：

Hello, Alice! Welcome to autotools.

如果想安装到系统（默认/usr/local/bin），运行：

sudo make install

然后你可以在任何终端运行hello：

hello

输出：

Hello, Alice! Welcome to autotools.

第7步：打包分发（可选）

如果你想把项目打包成.tar.gz包，让别人下载后能编译，只需要：

make dist

运行后，根目录会生成hello-1.0.tar.gz（版本号来自configure.ac里的AC_INIT）。别人下载后，只需要：

tar -xzvf hello-1.0.tar.gz
cd hello-1.0
./configure && make && make install

就能完成编译安装——这就是autotools的“标准化”魅力。

四、进阶：处理依赖和跨平台问题

真实项目不可能只有两个源文件，还会依赖第三方库（比如zlib、openssl），需要在不同系统上编译。autotools怎么处理这些问题？

1. 检查第三方库：AC_CHECK_LIB

假设你的项目需要用zlib压缩库（#include <zlib.h>，链接-lz），只需要在configure.ac里加一行：

# 检查zlib库（z是库名，gzopen是zlib里的函数，如果找到就定义HAVE_ZLIB）
AC_CHECK_LIB([z], [gzopen], [AC_DEFINE([HAVE_ZLIB], [1], [Have zlib library])])

AC_CHECK_LIB的参数是：库名、函数名、如果找到就执行的代码。这里如果找到zlib，就在config.h里定义HAVE_ZLIB宏，你可以在代码里这样用：

#ifdef HAVE_ZLIB
#include <zlib.h>
void compress_data() {
    // 使用zlib压缩
}
#else
void compress_data() {
    printf("zlib not supported, cannot compress.\n");
}
#endif

2. 处理跨平台头文件：AC_CHECK_HEADERS

不同系统的头文件路径可能不同，比如string.h在Linux和MacOS都有，但strings.h只在Linux有。你可以用AC_CHECK_HEADERS检查：

# 检查string.h和strings.h是否存在
AC_CHECK_HEADERS([string.h strings.h])

autoconf会在config.h里生成对应的宏（比如#define HAVE_STRING_H 1），代码里可以这样用：

#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif

3. 条件编译：AM_CONDITIONAL

如果你的项目需要根据系统类型编译不同代码（比如Linux用epoll，MacOS用kqueue），可以用AM_CONDITIONAL。比如在configure.ac里：

# 检查是否是Linux系统
AC_CANONICAL_HOST  # 获取系统类型信息
case $host_os in
    linux*)
        AM_CONDITIONAL([IS_LINUX], [true])  # 定义IS_LINUX条件为真
        ;;
    *)
        AM_CONDITIONAL([IS_LINUX], [false])  # 定义IS_LINUX条件为假
        ;;
esac

然后在Makefile.am里用条件判断：

# 如果是Linux，编译linux_specific.c
if IS_LINUX
hello_SOURCES += linux_specific.c
else
hello_SOURCES += bsd_specific.c
endif

五、autotools的“脾气”和“替代者”

autotools虽然强大，但有点“老派”，用起来需要遵守它的规则：

  • 文件名不能乱改：configure.ac、Makefile.am是固定名称，autoscan生成的configure.scan必须改名为configure.ac。
  • 目录结构有要求：建议用src/放源码、include/放头文件，automake默认识别这种结构。
  • 学习曲线陡峭：宏太多（AC_开头的有上百个），新手容易记不住，需要经常查文档（info autoconf或在线文档）。

现在也有更现代的替代工具，比如：

  • CMake：用CMakeLists.txt文件，语法更简单，支持Windows、Linux、MacOS，跨平台能力更强，适合新项目。
  • Meson：用Python语法的meson.build文件，速度更快，适合大型项目（如GNOME）。

但autotools在GNU项目里仍是“主流”，比如Linux内核、GCC、GIMP这些老牌项目都在用。理解autotools，不仅能维护老项目，还能帮你理解“构建系统”的核心思想——标准化、自动化、可移植。

六、总结：autotools教会我们的事

你可能会想：“现在有CMake，为什么还要学autotools？”其实，autotools更像一位“老师傅”，它教会我们：

  • 抽象问题：把“跨平台编译”抽象成“检查系统环境+生成适配规则”，而不是针对每个系统写不同代码。
  • 标准化流程：用./configure && make && make install三步曲，让用户不用关心项目细节，就能完成编译安装。
  • 工具链协作：autoscan、autoconf、automake各司其职，通过简单的文本文件（.ac、.am）协作完成复杂任务。

就像学数学不能只学计算器，还要学笔算一样，学构建系统不能只学CMake，还要学autotools。它让你明白“自动化”不是魔法，而是把重复劳动交给工具，自己专注于核心逻辑。

下次你看到一个开源项目用autotools，别再怕configure和Makefile.am了。记住：它们只是“模板工厂”的产物，你只需要告诉工厂“我的项目是什么样的”，剩下的，交给老伙计们搞定。

相关推荐

Oh！老伙计，提高自己的并发技能，先从锁优化开始吧

云上笔记 5 0 0

Linux下的C编译工具链autotools的使用

求阙者 66 0 0

给项目经理的建议

IT影子 118 0 0

给部署的项目设置域名访问

源码之路 82 0 0

我给自己搭建的前端导航网站，你们都别用

覃榜言 69 0 0

Linux如何实现项目自动化部署

IT影子 137 0 0

【Linux】Linux 项目自动化构建工具 -- make/makefile

快乐小鱼儿_9911 109 0 0

【Linux】Linux项目自动化构建工具—make/Makefile

闲云困兽 165 0 0

IntelliJ IDEA 新版 UI 中的项目导航改进

前端王祖蓝 72 0 0

在linux上基于shell自动部署Java项目

搬砖的小木匠 50 0 0

精彩评论（0）

0 0 举报