Linux软件安装：源代码与Tarball

文章目录

Linux源码包的安装与升级
- 什么是源代码、编译器与可执行文件
- 什么是函数库
- 什么是make与configure
- 什么是Tarball的软件
- 如何安装与升级软件
使用gcc进行编译的简单实例
- 单一程序：打印 Hello World
- 主、子程序链接：子程序的编译
- 调用外部函数库：加入链接的函数库
- gcc的简易用法(编译、参数与连接)
用make进行宏编译
- 为什么要用make
- makefile 的基本语法与变量
Tarball管理
- Tarball安装的基本步骤
- 一般 Tarball 软件安装的建议事项

Linux源码包的安装与升级

如果你想在自己的Linux服务器上运行网站，就需要安装一个Web服务器软件，否则无法提供Web服务。所以学会如何安装软件非常重要。

在Windows操作系统上安装软件很简单，只需要一直按下一步就可以。但是，因为Windows软件源代码是封闭的，所以无法修改它的功能或添加新功能。这就意味着，如果你的电脑受到病毒或黑客攻击，你只能等待软件开发商提供的修补程序，而不能自己修补。

相比之下，如果你在Linux上安装软件，你可以修改和自定义软件功能，甚至可以修补软件漏洞，因为Linux的软件源代码是开放的。这样可以增加你的电脑安全性，减少受到攻击的风险。

==Linux的优点在于它的软件几乎都是开放源代码的，这意味着每个软件都提供源代码，你可以自己修改它，以适合自己的需求。==开放源代码的好处在于你可以自由定制软件，增加或减少功能，甚至修补漏洞。但是，你需要理解什么是开放源代码，源代码是什么，以及在Linux上安装软件时，安装文件和源代码之间的关系。不同版本的Linux是否可以使用相同的执行文件，还是需要重新转换源代码，这些都是需要了解的概念。下面就以源代码与可执行文件来进行说明

什么是源代码、编译器与可执行文件

在Linux系统中，可执行文件是指二进制程序，比如 /usr/bin/passwd 和 /bin/touch 等文件。这些文件需要具有可执行权限（即有 x permission）才能被执行。与之不同的是，shell脚本是使用 shell 程序（如 bash）的功能进行一些判断，最终还是需要执行一些已经编译好的二进制程序。因此，shell本身也是一个二进制程序。

要判断一个文件是否为二进制程序，可以使用 file 命令来查看。

[root@localhost ~]# file /bin/bash
/bin/bash: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, BuildID[sha1]=85e3da5a087950e7aaeb7893c056218a8874d2e5, stripped

看到了吗？如果一个文件是二进制程序，并且具有可执行权限，那么使用 file 命令时会显示它的执行文件类别（如 ELF 64-bit LSB executable），同时也会显示是否使用动态函数库（shared libs）。如果一个文件只是一般的脚本，那么 file 命令会显示它是文本可执行文件（text executable）等字样。

既然Linux操作系统真正认识的其实是二进制程序，那么我们是如何做出这样的一个二进制程序的呢？制作一个二进制程序的过程分为两步：编写源代码和编译源代码。编写源代码时，我们使用的是文本编辑器，比如 vim，来写出一段程序的文字描述；这个文件就是源代码文件，它本质上是一个纯文本文件。接着，我们需要使用编译器来将这个源代码文件编译成操作系统认识的二进制程序。在Linux系统中，最常用的编程语言是C语言，所以我们可以使用标准的C语言编译器——gcc，来将C语言源代码文件编译成可执行的二进制程序。

流程图如下：

在编译过程中，编译器会将源代码文件编译成目标文件（object file），这些目标文件通常以 *.o 的扩展名存储。同时，我们在编写程序时，可能会引用或调用其他外部的子程序或函数，这时候我们需要在编译的过程中将这些函数库加入到我们的程序中。这样，编译器就会将所有的程序代码与函数库链接在一起，生成最终的可执行文件。在C语言中，源代码文件通常以 *.c 作为扩展名，而函数库文件通常以 *.a 或 *.so 的扩展名存储。

开放源代码：就是程序代码，写给人类看的程序语言，但机器并不认识，所以无法执行
编译器：将程序代码转译成为机器看得懂的语言，就类似翻译者的角色
可执行文件：经过编译器变成的二进制程序，机器看得懂所以可以执行

什么是函数库

在前面的流程图中，提到了函数库，那么什么是函数库？函数库是一组编写好的程序代码，可以在其他程序中被调用和重复使用。它们通常被组织成一个或多个文件，以便在需要时链接到程序中。在Linux系统中，PAM模块就是一个函数库，提供了验证用户身份和记录日志等功能，其他程序可以直接调用PAM的函数来实现身份认证，而不需要重新编写认证机制。此外，Linux内核也提供了很多函数库，可以供硬件开发者使用。

函数库又分为动态与静态函数库

如上图，如果需要使用一个函数库里面的函数，就需要在编译程序的时候加入相关的设置，让程序知道去哪里找到这个函数库。在Linux系统中，提供了很多与内核相关的函数库和参数，这些信息对于设计硬件驱动程序非常有用，它们通常被放置在/usr/include、/usr/lib、/usr/lib64这些目录中。

函数库：就类似子程序角色，是可以被调用来执行的一段功能函数

什么是make与configure

在使用类似gcc这样的编译器编译程序时，有多个程序文件需要编译，并且还需要写一个最终的链接程序。对于程序代码比较简短的情况，这并不是很麻烦，但是对于像WWW服务器软件(比如Apache)或者内核这样的大型程序，编译过程非常繁琐，需要写很多编译命令。为了简化这个过程，我们可以使用make命令来自动化编译过程，从而减少编译命令的编写量。

当使用make命令时，它会在当前目录下查找Makefile文件，这个文件记录了源代码如何编译的详细信息。make命令会自动判断源代码是否被修改过，如果有修改，则自动更新执行文件，这使得make成为了软件工程师非常实用的辅助工具。

make是一个程序，会去找Makefile，那么Makefile怎么写？通常软件开发商都会写一个检测程序来检测用户的操作环境，以及该操作环境是否有软件开发商所需要的其他功能，该检测程序检测完毕后，就会主动地建立中Makefile的规则文件，通常这个检测程序的文件名为configure或是config。

为什么要检测环境呢？因为不同版本的内核所使用的系统调用可能不同，每个软件所需要依赖的内核函数库也不同，同时，软件开发商不仅针对Linux开发，还可能针对整个UNIX-like系统进行开发，因此需要检测操作系统平台是否提供了所需要的编译器等工具。一般来说没检测程序会检测的内容大约有下面这些：

是否有适合的编译器可以编译本软件的程序代码
是否已经存在本软件所需要的函数库，或其他需要的依赖文件
操作系统平台是否适合本软件，包括Linux的内核版本
内核的头文件是否存在(驱动程序必须要的检测)

下面的图表明了整个过程中需要完成两个任务：

(1)执行configure来建立Makefile，这个步骤必须成功完成，只有成功之后才能(2)调用make命令进行编译所需的数据。简单来说，configure是在检测和设置编译环境之后生成Makefile，而make则是根据Makefile来编译执行文件。这两个命令在整个编译过程中起到了非常重要的作用。

什么是Tarball的软件

Tarball文件就是将软件的源代码文件使用tar命令打包成一个文件，再使用压缩技术将其压缩。最常见的压缩技术是gzip，因此Tarball文件的扩展名一般为.tar.gz或.tgz。由于利用了tar和gzip的功能，Tarball文件可以将软件的所有源代码文件打包在一起，方便用户进行传输和备份。近来，由于bzip2和xz的压缩率较高，Tarball文件也开始使用这些压缩技术，并相应地更改了扩展名，如.tar.bz2和.tar.xz等。用户在下载Tarball文件后，需要使用tar命令和相应的压缩解压工具进行解压缩，然后按照软件提供的安装说明进行编译和安装。所以说Tarball是一个软件包，你将它解压缩后，里面的文件通常就会有：

源代码文件
检测程序文件(可能是configure或config等文件)
本软件的建议说明与安装说明(README 或 INSTALL)

如何安装与升级软件

使用源代码编译安装：有些软件可能没有官方的软件包，只提供源代码，可以通过下载源代码并进行编译安装来安装软件，繁琐时间很漫长。

直接以编译好的二进制程序来安装与升级：这样做的好处就是省略了检测与编译等繁杂的过程。

那么源码包如何安装呢？基本流程是这样的

将Tarball 由厂商的网站下载
将Tarball 解开，产生很多的源代码文件
开始以GCC 进行源代码的编译 (会产生目标文件 object files)
然后以 gcc 进行函数库、主、子程序的链接，以形成主要的二进制文件
将上述的二进制文件以及相关的配置文件安装至自己的主机上面

使用gcc进行编译的简单实例

单一程序：打印 Hello World

我第一个程序的就是再屏幕上面打印【Hello World】的字样

首先你得确认你Linux系统立马已经安装了gcc，如果尚未安装gcc的话，需要安装一下gcc

[root@localhost ~]# yum install -y gcc

编写程序代码，就是源代码

[root@localhost ~]# vim hello.c
#include <stdio.h>
int main()
{
   printf ("hello,Word!\n");
}

开始编译与测试运行

[root@localhost ~]# gcc hello.c
[root@localhost ~]# ll hello.c a.out 
-rwxr-xr-x. 1 root root 8360 5月  28 19:05 a.out   # 此时会产生这个文件
-rw-r--r--. 1 root root   63 5月  28 19:04 hello.c
[root@localhost ~]# ./a.out 
hello,Word!

在默认状态下，如果我们直接使用gcc编译源代码，并且没有加上任何参数，那么生成的可执行文件的文件名会被自动设置为a.out，因此我们可以直接通过./a.out来运行它。

但是，如果我们想生成目标文件（比如hello.o）来进行其他操作，而且不想使用默认的a.out作为可执行文件的文件名，那该怎么办呢？这时候，我们可以使用以下命令来编译源代码：

[root@localhost ~]# gcc -c hello.c 
[root@localhost ~]# ll hello*
-rw-r--r--. 1 root root   63 5月  28 19:04 hello.c
-rw-r--r--. 1 root root 1496 5月  28 19:20 hello.o   # 这个就是被产生的目标文件
[root@localhost ~]# gcc -o hello hello.o
[root@localhost ~]# ll hello*
-rwxr-xr-x. 1 root root 8360 5月  28 19:21 hello     # 这个就是可执行文件，-o的结果
-rw-r--r--. 1 root root   63 5月  28 19:04 hello.c
-rw-r--r--. 1 root root 1496 5月  28 19:20 hello.o
[root@localhost ~]# ./hello 
hello,Word!
# -c表示只编译源代码，不进行链接操作  hello.c是源代码的文件名
# -o表示指定输出文件的文件名

这个步骤主要是利用hello.o这个目标文件制作出一个名为 hello 的执行文件。

那么你可能会觉得，只要生成一个a.out 就好了，干嘛要先定制目标文件再做成执行文件？

主、子程序链接：子程序的编译

如果我们在一个主程序里面又调用了另一个子程序？这是很常见的一个程序写法，因为可以提高整个程序的易读性。下面例子中，我么以thanks.c 整个主程序去调用 thanks_2.c 整个子程序

编写所需要的主、子程序

[root@localhost ~]# vim thanks.c
#include <stdio.h>
int main()
{
  printf ("Hello,word!\n");
  thanks_2();
}
# 上面的 thanks_2();那一行就是调用子程序
[root@localhost ~]# vim thanks_2.c
#include <stdio.h>
int thanks_2()
{
   printf ("Thank you!\n");
}

进行程序的编译与链接(link)

[root@localhost ~]# gcc -c thanks.c  thanks_2.c 
[root@localhost ~]# ll thanks*
-rw-r--r--. 1 root root   66 5月  28 20:16 thanks_2.c
-rw-r--r--. 1 root root 1504 5月  28 20:18 thanks_2.o  # 编译产生的
-rw-r--r--. 1 root root   76 5月  28 20:15 thanks.c
-rw-r--r--. 1 root root 1560 5月  28 20:18 thanks.o    # 编译产生的
[root@localhost ~]# gcc -o thanks thanks.o thanks_2.o 
[root@localhost ~]# ll thanks*
-rwxr-xr-x. 1 root root 8424 5月  28 20:19 thanks      # 最终结果产生了

执行一下这个文件

[root@localhost ~]# ./thanks 
Hello,word!
Thank you!

知道为什么要制作出目标文件了吗？在编写程序的过程中，我们通常会将程序分为多个源代码文件，每个文件都实现了程序的一部分功能。如果我们直接编译所有的源代码文件，那么编译器就需要把所有的代码都编译成一个目标文件或可执行文件，这会导致编译时间过长和可维护性差。
为了解决这个问题，我们可以先将每个源代码文件编译成一个目标文件，这个目标文件包含了该文件中所有的函数和变量的二进制代码。然后在链接阶段，将所有的目标文件链接在一起，生成一个可执行文件或库文件。
这种分步编译的方式可以加快编译速度，同时也方便了程序的维护和更新。如果我们修改了一个源代码文件，只需要重新编译这个文件，然后链接所有的目标文件即可，而不需要重新编译整个程序。
因此，制作目标文件是为了方便程序的编译和维护，同时也提高了编译的效率。

调用外部函数库：加入链接的函数库

如果我们想要计算出三角函数里面的sin(90度角)。要注意的是，大多数的程序语言都是使用弧度而不是一般我们计算的【角度】，180度叫约等于3.14弧度

[root@localhost ~]# vim sin.c
#include <stdio.h>
#include <math.h>
int main()
{
  float value;
  value = sin ( 3.14 / 2);
  printf ("%f\n",value);
}

那要如何编译这个程序？我们先直接编译看看

[root@localhost ~]# gcc sin.c
#  新的gcc会主动将函数放进来给你用，所以只要加上 include <math.h>就好了

新版的gcc编译器可以自动识别需要链接的函数库，并将其包含在编译过程中，这样就可以避免一些奇怪的错误信息。例如，数学函数库的名称是libm.so，编译时可以使用-lm参数来链接该库。
需要注意的是，libm.so函数库通常被放置在系统默认的/lib和/lib/64目录下，因此无需使用-L参数来指定库文件的查找目录。

编译时加入额外函数库链接的方式

[root@localhost ~]# gcc sin.c -lm -L/lib -L/lib64   # 重点在-lm
[root@localhost ~]# ./a.out                         # 尝试执行新文件
1.000000

-l：是【加入某个函数库(library)】的意思
m：则是libm.so 这个函数库，其中，lib 与扩展名 (.a 或.so)不需要写

所以 -lm 表示使用 libm.so (或libm.a)这个函数库的意思，至于那个-L 后面接的路径表示：【我要的函数库libm.so 请到 /lib 或 /lib64 里面查找】

在Linux系统中，默认情况下函数库被放置在/lib和/lib64目录下，因此在编译程序时不需要使用-L/lib和-L/lib64参数进行指定。
但是，如果你使用的函数库不在这两个目录下，就需要使用-L参数来指定函数库所在的路径，否则编译器无法找到函数库文件。
除了链接函数库，我们还需要使用#include指令来引入其他的头文件，以便在程序中使用该头文件中定义的函数和变量。例如，在sin.c文件中，我们使用了stdio.h头文件中定义的printf函数。
通常情况下，头文件被放置在/usr/include目录下。但是，如果你的头文件不在这个目录下，就需要使用-I参数来指定头文件所在的路径。这样编译器就可以找到并正确地引用头文件中定义的函数和变量

[root@localhost ~]# gcc sin.c -lm -I/usr/include

gcc的简易用法(编译、参数与连接)

gcc常用的参数如下

# 仅将源代码编译成为目标文件
[root@localhost ~]# gcc -c hello.c
# 会自动产生hello.o 这个文件，但是并不会产生二进制执行文件

# 在编译的时候，根据操作环境给予最佳执行速度
[root@localhost ~]# gcc -O hello.c -c
# 会自动参数hello.o 这个文件，并且执行速度最佳

# 在进行二进制文件制作时，将链接的函数库与相关的路径加入
[root@localhost ~]# gcc sin.c -lm -L/lib/ -I/usr/include
# 这个命令较常使用在最终链接成为二进制文件的时候
# -lm 指的是 libm.so 或 libm.a 这个函数库文件
# -L 后面接的是路径是刚刚上面那个函数库的查找目录
# -I 后面接的是源代码内的 include 文件之所在目录

# 将编译结果输出成某个特定文件名
[root@localhost ~]# gcc -o hello hello.c
# -o 后面接的是要输出的二进制文件名

# 在编译的时候，输出较多的信息说明
[root@localhost ~]# gcc -o hello hello.c -Wall
# 加入 -Wall之后，程序的编译会变的较为严谨一点，所以警告信息也会显示出来

用make进行宏编译

为什么要用make

先来想象一个案例，假设我的执行文件里面包含了4个源代码文件，分别是main.c、haha.c 、 sin_value.c 、cos_value.c ，这4个文件的目的是：

main.c：主要的目的是让用户输入角度与调用其他3个子程序
haha.c：输出一堆有的有没的信息
sin_value.c：计算用户输入的角度(360)的sin值
cos_value.c：计算用户输入的角度(360)的cos值

由于这四个文件里面包含了相关性，并且还用到数学函数，所以如果想让这个程序可以运行，那么就需要这样编译：

先进行目标文件的编译，最终会有四个 *.o 的文件名出现

[root@localhost ~]# gcc  -c main.c
[root@localhost ~]# gcc  -c haha.c
[root@localhost ~]# gcc  -c sin_value.c
[root@localhost ~]# gcc  -c cos_value.c

再进行链接成为执行文件，并加入libm数学函数，以产生main执行文件

[root@localhost ~]# gcc -o main main.o haha.o sin_value.o cos_value.o -lm

本程序的执行结果，必须输入姓名、360度角的角度来计算

[root@localhost ~]# ./main
Please input your name: CSQ
Please enter the degree angle (ex> 90): 30
Hi，Dear CSQ，nice to meet you.
The Sin is: 0.50
The Cos is: 0.87

可以看到编译的过程需要进行很多操作，而且如果要重新编译，则上述的流程要得重新来一遍。这时候我们就可以用make这个工具。在这个目录下建立一个名为 makefile 的文件，内容如下：

先编辑 makefile 这个规则文件，内容只要有 main 这个执行文件

[root@localhost ~]# vim makefile
main:main.o haha.o sin_value.o cos_value.o
	gcc -o main main.o haha.o sin_value.o cos_value.o -lm
# 注意：第二行的gcc之前是<tab>按键产生的空格

尝试使用makefile制订的规则进行编译操作

[root@localhost ~]# make
cc        -c  -o main.o main.c
cc        -c  -o haha.o haha.c
cc        -c  -o sin_value.o sin_value.c
cc        -c  -o cos_value.o cos_value.c
gcc  -o  main main.o haha.o sin_value.o cos_value.o -lm
# 此时make会去读取makefile的内容，并根据内容直接去给它编译相关的文件

在不删除任何文件的情况下，重新执行一次编译的操作

[root@localhost ~]# make
make: `main' is up to date
# 只会进行更新(update)的操作而已

make是一个工具，可以自动化编译程序，它可以帮助程序员在修改代码后，只编译修改过的部分，从而节省编译时间。使用make可以方便地编译程序，因为它会自动判断哪些文件需要重新编译，而不必手动编译每个文件。这样可以让程序员更加专注于程序的开发，而不必花费太多时间在编译上。

make的好处：

简化编译时所需执行的命令
若在编译完成之后，修改了某个源代码文件，则make仅会针对被修改的文件进行编译，其他文件不会被修改
最后可以依照依赖性来更新(update)执行文件

而make里面最需要注意的就是makefile规则文件

makefile 的基本语法与变量

基本的makefile规则是这样的

目标(target):目标文件1 目标文件2
<tab> gcc -o 欲建立的执行文件 目标文件1 目标文件2

特别注意：命令行必须要以Tab键作为开头才行

在makefile当中的 # 代表注释
需要在命令行(例如gcc这个编译器命令)的第一个字符
目标(target)与依赖文件(就是目标文件)之间需要以【:】隔开

那么如果我要有两个以上的操作呢？例如执行一个命令就直接清楚掉所有目标文件与执行文件.

先编辑makefile 建立新的规则，此规则的标的名称为 clean

[root@localhost ~]# vim makefile
main:main.o haha.o sin_value.o cos_value.o
	gcc -o main main.o haha.o sin_value.o cos_value.o -lm
clean:
	rm -f main main.o haha.o sin_value.o cos_value.o

以新的目标(clean)测试看看执行make的结果

[root@localhost ~]# make clean    # 通过 make 以 clean 为目标
rm -rf main main.o haha.o sin_value.o cos_value.o

如此一来，我们的makefile中就具有至少两个目标，分别是 main 与 clean：如果我们想要建立 main 的话，输入【make main】；如果想要清楚所有文件，输入【make clean】即可。而如果想要清除目标文件再编译 main 这个程序的话，就可以输入【make clean main】，如下所示

[root@localhost ~]# make clean main

如果你觉得makefile怎么重复输入的数据这么多，可以使用shell脚本学到的【变量】来简化makefile

[root@localhost ~]# vim makefile
LIBS = -lm
OBJS = main.o haha.o sin_value.o cos_value.o
main: ${OBJS}
        gcc -o main ${OBJS} ${LIBS}
clean:
        rm -f main ${OBJS}

bash shell 脚本的语法有点不太相同，变量的基本语法为：

变量与变量内容以【=】隔开，同时两边可以具有空格
变量左边不可以有，例如上述例子一样
在习惯上，变量最好是以【大写字母】为主
运行变量时，以 ${变量}或$ (变量)使用；
在该shell的环境变量是可以被套用的
在命令行模式也可以设置变量

由于gcc 在进行编译的操作时，会主动读取 CFLAGS这个环境变量，所以，你可以直接在 shell 中定义出这个环境变量，也可以在 makefile 文件里面去定义，更可以在命令行中设置这个东西，例如：

[root@localhost ~]# CFLAGS="-Wall" make clean main
# 这个操作在使用 make进行编译时，会去读取 CFLAGS 的变量内容

也可以这样

LIBS = -lm
OBJS = main.o haha.o sin_value.o cos_value.o
CFLAGS = -Wall
main: ${OBJS}
        gcc -o main ${OBJS} ${LIBS}
clean:
        rm -f main ${OBJS}

那么万一这个CFLAGS 的内容在命令行与makefile里面并不相同，以哪个方式输入为主呢？

环境变量规则是这样的：

make命令行后面加上的环境变量为优先
makefile 里面指定的环境变量第二
shell原本具有的环境变量第三

此外，还有一些特殊的变量需要了解

$@：代表目前的目标(target)

所以我也可以将makefile改成：

LIBS = -lm
OBJS = main.o haha.o sin_value.o cos_value.o
CFLAGS = -Wall
main: ${OBJS}
        gcc -o $@ ${OBJS} ${LIBS}  # $@ 就是 main
clean:
        rm -f main ${OBJS}

Tarball管理

从源代码的说明我们知道制作一个二进制程序需要很多东西，这包括下面这些基础的软件。

gcc或cc等C语言编译器
make及autoconfig等软件
需要内核提供的Library以及相关的include文件

Tarball安装的基本步骤

以 Tarball 方式发布的软件是源代码的形式，需要经过编译成二进制程序才能运行。所以，我们需要先将 Tarball 文件解压缩，得到源代码文件，然后在源代码所在的目录下建立一个 Makefile 文件，这个文件会告诉计算机如何编译和安装这个软件，最后使用 make 命令进行编译和安装操作，生成可执行的二进制程序。

所以整个安装的基础操作如下：

获取原始文件：首先需要从网上下载一个.tar.gz 或 .tar.bz2 格式的压缩文件，然后将它解压缩到 /usr/local/src 目录下。
获取步骤流程：进入解压后的目录，查看里面的一些重要文件，比如 INSTALL 和 README，这些文件会告诉你需要安装哪些依赖的软件。
依赖属性软件安装：如果有依赖软件需要安装，那么就按照文件里的提示安装好依赖软件
建立makefile ：使用一个名为 configure 或 config 的程序来检测操作环境，并生成一个名为 Makefile 的文件，这个文件会告诉编译器需要进行哪些操作，比如编译、链接等。
编译：用make这个程序，并使用该目录下的Makefile做为它1的参数配置文件，来进行make(编译或其他)的操作。
安装：使用 make install 命令来安装程序，这个命令会根据 Makefile 文件里的指令将程序安装到正确的路径。

一般 Tarball 软件安装的建议事项

Linux发行版发布安装的软件大多是在 /usr 里面

而用户自行安装的软件则建议放置在 /usr/local 里面(这考虑到了管理用户所安装软件的便利性)

/usr/local/ 目录下的一些常见文件和文件夹：

/usr/local/bin/：存放本地安装的可执行文件。
/usr/local/include/：存放本地安装的头文件。
/usr/local/lib/：存放本地安装的库文件。
/usr/local/share/：存放本地安装的共享文件，例如文档、图像和音频文件等。
/usr/local/src/：存放本地安装的源代码。
/usr/local/etc/：存放本地安装的配置文件。
/usr/local/man/：存放本地安装的 man 页面。

如果每个软件都选择安装在默认的路径下，也就是 /usr/local/ 目录下，那么所有软件的文件都会被放置在同样的四个目录中，即 /bin、/include、/lib 和 /share 目录中。因此，如果你在这个目录下安装了很多软件，那么在未来想要升级或删除这些软件时，可能会比较难以追查每个文件的来源。而如果你再安装的时候选择的是单独的目录，例如我将apache安装再 /usr/local/apache当中，那么你的文件目录就会变成

/usr/local/apache/etc
/usr/local/apache/bin
/usr/local/apache/lib
/usr/local/apache/man

因为单个软件的所有文件都被安装在同一个目录下，所以要删除这个软件就比较容易，只需要将这个目录删除即可。比如，如果要删除 Apache 这个软件，只需要执行命令【rm -rf /usr/local/apache】即可。但是，在实际安装软件的时候，还需要查看该软件的 Makefile 文件中的安装信息，才能了解该软件的具体安装情况。因为有些软件可能会在其他目录下安装一些文件，如果不了解具体情况就直接删除目录，可能会遗漏掉某些文件，导致软件无法正常卸载或者出现问题。