凡有成者，必务于实。凡有所学，皆成性格。
Linux编译工具：gcc入门
1. 什么是gcc
gcc的全称是GNU Compiler Collection ，它是一个能够编译多种语言的编译器。最开始gcc是作为C语言的编译器（GNU C Compiler），现在除了c语言，还支持C++、java、Pascal等语言。gcc支持多种硬件平台
2. gcc的特点
gcc是一个可移植的编译器，支持多种硬件平台。例如ARM、X86等等。 gcc不仅是个本地编译器，它还能跨平台交叉编译。所谓的本地编译器，是指编译出来的程序只能够在本地环境进行运行。而gcc编译出来的程序能够在其他平台进行运行。例如嵌入式程序可在x86上编译，然后在arm上运行。 gcc有多种语言前端，用于解析不同的语言。 gcc是按模块化设计的，可以加入新语言和新CPU架构的支持。 gcc是自由软件。任何人都可以使用或更改这个软件。 3. gcc编译程序的过程
gcc编译程序主要经过四个过程：
预处理（Pre-Processing）
编译 （Compiling）
汇编 （Assembling）
链接 （Linking）链接过程会将程序所需要的目标文件进行链接成可执行文件,对于多个目标文件.o ，就是在这一步合成可执行文件
4. gcc常用选项
来看一下gcc常用选项
g选项名 作用
-o 指定目标文件名，可以产生各个阶段.i、.s、.o、可执行文件等：只要指定 gcc -o 目标文件名 源文件.cpp 其中目标文件后缀可以：.i、.s、.o、可执行文件（无后缀）
-E 只运行C预编译器生成.i文件
-S 告诉编译器产生汇编程序文件后停止编译，产生的汇编语言文件拓展名为.s
-c 仅执行编译操作，不进行连接操作。（只生成.o文件）
-Wall 使gcc对源文件的代码有问题的地方发出警告
-Idir 将dir目录加入搜索头文件的目录路径(这里的 dir需要改成头文件所在的目录)
-Ldir 将dir目录加入搜索库的目录路径（这里的dir需要改成库所在的目录）
-llib 连接lib库（lib需要替换成我们的库名）
-g 在目标文件中嵌入调试信息，以便gdb之类的调试程序调试例子：
gcc -E hello.c -o hello.i 对hello.c文件进行预处理，生成了hello.i 文件
gcc -S hello.i -o hello.s 对预处理文件进行编译，生成了汇编文件
gcc -c hello.s -o hello.o 对汇编文件进行编译，生成了目标文件
gcc hello.o -o hello 对目标文件进行链接，生成可执行文件
gcc hello.c -o hello 直接编译链接成可执行目标文件
gcc -c hello.c 或 gcc -c hello.c -o hello.o 编译生成可重定位目标文件对于需要使用静态、动态库的编译
使用命令：
gcc -Wall main.c libhello.a -o main
其中.a是我们的静态库文件
也就是说和普通.c文件一样，同时多文件编译
注意：库文件必须在下面的目录
/usr/include及其子目录底下的include文件夹
/usr/local/include及其子目录底下的include文件夹
/usr/lib
/usr/local/lib
/lib
如果库文件不在上述目录（比如自己生成的库），则可以执行以下命令：
gcc -Wall -L. main.c -o main -lhello 【lhello 是 libhello的缩写】
其中 -L.表示库文件的位置在当前目录下，由于libhello.a是我们自己生成的，并存放在当前录下下，所以需要加上-L.选项。默认库文件是在系统的目录下进行搜索。同样的，-I.选项用于头文件的搜索。使用gcc时可以加上-Wall选项 。下面这个例子如果不加上-Wall选项，编译器不会报出任何错误或警告，但是程序的结果却不是预期的：
//bad.c
#include<stdio.h>
int main()
{
printf("the number is %f ",5); //程序输出了the number is 0.000000，结果错误
return 0;
}使用-Wall选项：
gcc -Wall bad.c -o bad
gcc将输出警告信息：
warning: format ‘%f’ expects argument of type ‘double’, but argument 2 has type ‘int’ [-Wformat=]
printf("the number is %f\n",5);5. gcc编译多个文件
假设现在有三个文件：hello.c hello.h main.c ,三个文件的内容如下：
// hello.c
#include<stdio.h>
#include"hello.h"
void printHello()
{
printf("hello world!\n");
}
//main.c
#include<stdio.h>
#include"hello.h"
int main()
{
printHello();
return 0;
}
//hello.h
//仅包含函数声明
#ifndef _HELLO_
#define _HELLO_
void printHello();
#endif编译这三个文件，可以一次编译：
gcc hello.c main.c -o main 生成可执行文件main也可以独立编译：（必须全部都编译成.o文件，最后经过链接成可执行文件）
gcc -Wall -c main.c -o main.o
gcc -Wall -c hello.c -o hello.o
gcc -Wall main.o hello.o -o main独立编译的好处是，当其中某个模块发送改变时，只需要编译该模块就行，不必重新编译所有文件，这样可以节省编译时间。
6. 使用外部库:静态库.a和动态库.sa/.so
在使用C语言和其他语言进行程序设计的时候，我们需要头文件来提供对常数的定义和对系统及库函数调用的声明。库文件是一些预先编译好的函数集合 ，那些函数都是按照可重用原则编写的。它们通常由一组互相关联的可重用原则编写的它们通常由一组互相关联的用来完成某项常见工作的函数构成。使用库的优点在于：
模块化的开发 可重用性 可维护性 库又可以分为静态库与动态库：
静态库（.a） ：程序在编译链接的时候把库的代码链接到可执行文件中。程序运行的时候将不再需要静态库。静态库比较占用磁盘空间，而且程序不可以共享静态库。运行时也是比较占内存的，因为每个程序都包含了一份静态库。动态库（.so或.sa） ：程序在运行的时候才去链接共享库的代码，多个程序共享使用库的代码，这样就减少了程序的体积。一般头文件或库文件的位置在：
/usr/include及其子目录底下的include文件夹
/usr/local/include及其子目录底下的include文件夹
/usr/lib
/usr/local/lib
/lib7. 生成静态库 ar rcs libhello.a hello.o
为了生成.a文件，我们需要先生成.o文件 。下面这行命令将我们的hello.o打包成静态库libhello.a ：
将.o文件打包成静态库.a
ar rcs libhello.a hello.o
ar是gun归档工具，rcs表示replace and create，如果libhello之前存在，将创建新的libhello.a并将其替换。然后就可以这样来使用静态库libhello.a
gcc -Wall main.c libhello.a -o main令外还有一种方法：
gcc -Wall -I../include -L. main.c -o main -lhello 【lhello 是 libhello的缩写】其中 -L.表示库文件的位置在当前目录下，由于libhello.a是我们自己生成的，并存放在当前录下下，所以需要加上-L.选项。默认库文件是在系统的目录下进行搜索。同样的，-I.选项用于头文件的搜索。
头文件 .h的使用和编译（-I参数是用来指定头文件目录）
编写C和C++程序时，需要在代码中使用#include来引用头文件。除了这个方法外，gcc支持参数-include，可以在编译时直接向目标代码中添加头文件，而不需要在代码中加入include语句。
最省事的方法：在文件中直接使用#include xxxxxx实现 编写单独的 .cpp 文件来实现 函数 或者 变量 ，在主函数使用前需要声明变量为外部变量。不然编译可以通过，但是在目标文件链接的时候就会出错。也就是说我们编写库的时候需要extern 函数，如果不外加.h文件时 #include<iostream>
using namespace std;
extern int test;
extern void test_fun(int& temp);
int main()
{
cout << test << endl;
test_fun(test);
cout << test << endl;
return 0;
}也可以通过建立一个.h文件来说明一些外部的变量和函数。这样通过引用头文件就可以实现真确的编译及链接。这种情况下需要引用该头文件 test.h 文件
#pragma once
#include<iostream>
using namespace std;
extern int intext; //外部变量
void test_function();
extern void function();//外部函数如何引用头文件：
-include用来包含头文件，但一般情况下包含头文件都在源码里用#include xxxxxx实现，-include参数很少用。-I参数是用来指定头文件目录，/usr/include目录一般是不用指定的，gcc知道去那里找，但是如果头文件不在/usr/include里我们就要用-I参数指定了，比如头文件放在/myinclude目录里，那编译命令行就要加上-I/myinclude参数了，如果不加你会得到一个”xxxx.h: No such file or directory”的错误。-I参数可以用相对路径，比如头文件在当前目录，可以用-I.来指定。
8. 生成使用共享库
生成一个共享库，名称的规则是libxxx.so。将刚才hello.o生成libhello.so的命令为：
gcc -shared -fPIC hello.o -o libhello.so生成了共享库之后，可以这样来使用共享库：
gcc -Wall main.o -o main -L. -I. -lhello该命令与使用静态库的命令相同，但是在共享库与静态库共存的情况下，优先使用共享库。
共享库有时候并不不在当前的目录下，为了让gcc能够找得到共享库，有下面几种方法：
拷贝.so文件到系统共享库路径下，一般指/usr/lib
在~/.bash_profile文件中，配置LD_LIBRARY_PATH变量
配置/etc/ld.so.conf，配置完成后调用ldconfig更新ld.so.cache
其中，shared选项表示生成共享库格式。fPIC表示产生位置无关码（position independent code），位置无关码表示它的运行、加载与内存位置无关，可以在任何内存地址进行加载。GCC在链接过程中，对参数中哭的顺序是有要求的
参数右侧的库会先于左侧库的加载，也就是说参数的解析是从右往左的
gcc -o bin -lB -lA9. 库的搜索路径
库的搜索路径遵循几个搜索原则：从左到右搜索-I -l指定的目录，如果在这些目录中找不到，那么gcc会从由环境 变量指定的目录进行查找。头文件的环境变量是C_INCLUDE_PATH,库的环境变量是LIBRARY_PATH.如果还是找不到，那么会从系统指定指定的目录进行搜索。
动态库的路径问题为了让执行程序顺利找到动态库:
例如动态库libhello.so在/home/ting/lib目录下，以bash为例，
编辑$HOME下.profile文件添加如下：
$export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/ting/libGCC:GNU Compiler Collection(GUN 编译器集合)，它可以编译C、C++、JAV、Fortran、Pascal、Object-C等语言。
gcc是GCC中的GUN C Compiler（C 编译器）
g++是GCC中的GUN C++ Compiler（C++编译器）
由于编译器是可以更换的，所以gcc不仅仅可以编译C文件
所以，更准确的说法是：gcc调用了C compiler，而g++调用了C++ compiler
gcc和g++的主要区别
对于 .c和 .cpp文件，gcc分别当做c和cpp文件编译（c和cpp的语法强度是不一样的） 对于 .c和 .cpp文件，g++则统一当做cpp文件编译 使用g++编译文件时，g++会自动链接标准库STL，而gcc不会自动链接STL gcc在编译C文件时，可使用的预定义宏是比较少的 gcc在编译cpp文件时/g++在编译c文件和cpp文件时（这时候gcc和g++调用的都是cpp文件的编译器），会加入一些额外的宏。 6.在用gcc编译c++文件时，为了能够使用STL，需要加参数 –lstdc++ ，但这并不代表 gcc –lstdc++ 和 g++等价，它们的区别不仅仅是这个。
Makefile:规定编译的顺序规则 make就是一个gcc/g++的调度器
代码变成可执行文件，叫做编译（compile）；先编译这个，还是先编译那个（即编译的安排），叫做构建（build）。
Make是最常用的构建工具，诞生于1977年，主要用于C语言的项目。但是实际上 ，任何只要某个文件有变化，就要重新构建的项目，都可以用Make构建。
make命令执行时，需要一个名为makefile的 文件，以告诉make命令需要怎么样的去编译和链接程序。
重点：gcc和make区别
gcc是编译器 而make不是 make是依赖于Makefile来编译多个源文件的工具 在Makefile里同样是用gcc(或者别的编译器)来编译程序.
gcc是编译一个文件，make是编译多个源文件的工程文件的工具。
make就是一个gcc/g++的调度器，通过读入一个文件（默认文件名为Makefile或者makefile），执行一组以gcc/g++为主的shell命令序列。输入文件主要用来记录文件之间的依赖关系和命令执行顺序。gcc是编译工具； make是定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译； 也就是说make是调用gcc的。
Makefile的编写规则
commmond每行命令之前必须有一个tab键。如果想用其他键，可以用内置变量.RECIPEPREFIX声明。
https://seisman.github.io/how-to-write-makefile/introduction.html
https://www.ruanyifeng.com/blog/2015/02/make.html
编写 Makefile的文件：
target ... : prerequisites ...
[tab]
command
…
…
或者：
targets : prerequisites ; command
command
…
执行：make 目标target名
target
可以是一个object file（目标文件），也可以是一个执行文件，还可以是一个标签（label）。对于标签这种特性，在后续的“伪目标”章节中会有叙述。
prerequisites
生成该target所依赖的文件和/或target
command（任意的命令）每行命令之前必须有一个tab键。如果想用其他键，可以用内置变量.RECIPEPREFIX声明。
该target要执行的命令（任意的shell命令）
command是命令行，如果其不与“target:prerequisites”在一行，那么，必须以 Tab 键开头，如果和prerequisites在一行，那么可以用分号做为分隔。（见上）
prerequisites也就是目标所依赖的文件（或依赖目标）。如果其中的某个文件要比目标文件要新，那么，目标就被认为是“过时的”，被认为是需要重生成的。这个在前面已经讲过了。
如果命令太长，你可以使用反斜杠（ \ ）作为换行符。make对一行上有多少个字符没有限制。规则告诉make两件事，文件的依赖关系和如何生成目标文件。
一般来说，make会以UNIX的标准Shell，也就是 /bin/sh 来执行命令。
例如：
Makefile的文件:
a.txt: b.txt c.txt
cat b.txt c.txt > a.txt
构建命令：
$ make a.txt
一个目标（target）就构成一条规则。目标通常是文件名，指明Make命令所要构建的对象，比如上文的 a.txt 。目标可以是一个文件名，也可以是多个文件名，之间用空格分隔。
除了文件名，目标还可以是某个操作的名字，这称为”伪目标”（phony target）。
clean:
rm *.o
上面代码的目标是clean，它不是文件名，而是一个操作的名字，属于"伪目标 "，作用是删除对象文件。
$ make clean井号（#）在Makefile中表示注释
make命令
执行时，需要一个makefile文件，以告诉make命令需要怎么样的去编译和链接程序。
首先，我们用一个示例来说明makefile的书写规则，以便给大家一个感性认识。这个示例来源于gnu 的make使用手册，在这个示例中，我们的工程有8个c文件，和3个头文件，我们要写一个makefile来告诉make命令如何编译和链接这几个文件。我们的规则是：
如果这个工程没有编译过，那么我们的所有c文件都要编译并被链接。
edit : main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
cc -o edit main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
main.o : main.c defs.h
cc -c main.c
kbd.o : kbd.c defs.h command.h
cc -c kbd.c
command.o : command.c defs.h command.h
cc -c command.c
display.o : display.c defs.h buffer.h
cc -c display.c
insert.o : insert.c defs.h buffer.h
cc -c insert.c
search.o : search.c defs.h buffer.h
cc -c search.c
files.o : files.c defs.h buffer.h command.h
cc -c files.c
utils.o : utils.c defs.h
cc -c utils.c
clean :
rm edit main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o反斜杠（ \ ）是换行符的意思。这样比较便于makefile的阅读。我们可以把这个内容保存在名字为“makefile”或“Makefile”的文件中，然后在该目录下直接输入命令 make 就可以生成执行文件edit。如果要删除执行文件和所有的中间目标文件，那么，只要简单地执行一下 make clean 就可以了。
在这个makefile中，目标文件（target）包含：执行文件edit和中间目标文件（ *.o ），依赖文件（prerequisites）就是冒号后面的那些 .c 文件和 .h 文件。每一个 .o 文件都有一组依赖文件，而这些 .o 文件又是执行文件 edit 的依赖文件。依赖关系的实质就是说明了目标文件是由哪些文件生成的，换言之，目标文件是哪些文件更新的。
在定义好依赖关系后，后续的那一行定义了如何生成目标文件的操作系统命令，一定要以一个 Tab 键作为开头。记住，make并不管命令是怎么工作的，他只管执行所定义的命令。make会比较targets文件和prerequisites文件的修改日期，如果prerequisites文件的日期要比targets文件的日期要新，或者target不存在的话，那么，make就会执行后续定义的命令。
这里要说明一点的是， clean 不是一个文件，它只不过是一个动作名字，有点像c语言中的label一样，其冒号后什么也没有，那么，make就不会自动去找它的依赖性，也就不会自动执行其后所定义的命令。要执行其后的命令，就要在make命令后明显得指出这个label的名字。这样的方法非常有用，我们可以在一个makefile中定义不用的编译或是和编译无关的命令，比如程序的打包，程序的备份，等等。
回声
正常情况下，make会打印每条命令，然后再执行，这就叫做回声（echoing）。
test:
# 这是测试
执行上面的规则，会得到下面的结果。
$ make test
# 这是测试模式匹配
Make命令允许对文件名，进行类似正则运算的匹配，主要用到的匹配符是%。比如，假定当前目录下有 f1.c 和 f2.c 两个源码文件，需要将它们编译为对应的对象文件。
%.o: %.c等同于下面的写法。
f1.o: f1.c
f2.o: f2.c使用匹配符%，可以将大量同类型的文件，只用一条规则就完成构建。
变量 变量需要放在 $( )
Makefile 允许使用等号自定义变量。
txt = Hello World
test:
@echo $(txt)上面代码中，变量 txt 等于 Hello World。调用时，变量需要放在 $( ) 之中。
调用Shell变量，需要在美元符号前，再加一个美元符号，这是因为Make命令会对美元符号转义。
多个文件目录下Makefile的写法：！有用的实例
1.有用的网址：
https://seisman.github.io/how-to-write-makefile/conditionals.html
2.对于多个文件都在同一目录下：
测试程序在同一个文件中，共有func.h、func.c、main.c三个文件，Makefile写法如下所示：
makefile文件：
##-wall 使gcc对源文件的代码有问题的地方发出警告
CC = gcc
CFLAGS = -g -Wall
main:main.o func.o
$(CC) main.o func.o -o main
main.o:main.c
$(CC) $(CFLAGS) -c main.c -o main.o
func.o:func.c
$(CC) $(CFLAGS) -c func.c -o func.o
clean:
rm -rf *.o执行：
make 目标3、通用模板
实际当中程序文件比较大，这时候对文件进行分类，分为头文件、源文件、目标文件、可执行文件。也就是说通常将文件按照文件类型放在不同的目录当中，这个时候的Makefile需要统一管理这些文件，将生产的目标文件放在目标目录下，可执行文件放到可执行目录下。测试程序如下图所示：
# innclude目录：.h头文件
# src： .c源文件
# obj: 生成的可执行文件main
# bin： .o文件（编译过程的中间文件）
DIR_INC = ./include
DIR_SRC = ./src
DIR_OBJ = ./obj
DIR_BIN = ./bin
SRC = $(wildcard ${DIR_SRC}/*.c)
OBJ = $(patsubst %.c,${DIR_OBJ}/%.o,$(notdir ${SRC}))
TARGET = main
BIN_TARGET = ${DIR_BIN}/${TARGET}
CC = gcc
CFLAGS = -g -Wall -I${DIR_INC}
${BIN_TARGET}:${OBJ}
$(CC) $(OBJ) -o $@
${DIR_OBJ}/%.o:${DIR_SRC}/%.c
$(CC) $(CFLAGS) -c $< -o $@
.PHONY:clean
clean:
find ${DIR_OBJ} -name *.o -exec rm -rf {}解释如下：
（1）Makefile中的 符号 $@, $^, $< 的意思：
（2）wildcard、notdir、patsubst的意思：
wildcard : 扩展通配符
SRC = $(wildcard *.c)
等于指定编译当前目录下所有.c文件，如果还有子目录，比如子目录为inc，则再增加一个wildcard函数，象这样：
SRC = $(wildcard .c) $(wildcard inc/ .c)
（3）gcc -I -L -l的区别：
gcc -o hello hello.c -I /home/hello/include -L /home/hello/lib -lworld
上面这句表示在编译hello.c时-I /home/hello/include表示将/home/hello/include目录作为第一个寻找头文件的目录， 寻找的顺序是：/home/hello/include–>/usr/include–>/usr/local/include
-L /home/hello/lib表示将/home/hello/lib目录作为第一个寻找库文件的目录，
寻找的顺序是：/home/hello/lib–>/lib–>/usr/lib–>/usr/local/lib
-lworld表示在上面的lib的路径中寻找libworld.so动态库文件（如果gcc编译选项中加入了“-static”表示寻找libworld.a静态库文件）autoconf和automake工具
autoconf和automake两个工具来帮助我们自动地生成符合自由软件惯例的Makefile
https://thebigdoc.readthedocs.io/en/latest/auto-make-conf.html
步骤：
create project
touch NEWS README ChangeLog AUTHORS
autoscan
configure.scan ==> configure.in/configure.ac
aclocal
autoheader(可选，生成config.h.in)
Makefile.am(根据源码目录可能需要多个)
libtoolize –automake –copy –force(如果configure.ac中使用了libtool)
automake –add-missing
autoconf
./configure && make && make install安装：
sudo apt-get install autoconf例子：
https://www.laruence.com/2009/11/18/1154.html
打印当前工作目录 pwd 命令
Linux中用 pwd 命令来查看”当前工作目录“的完整路径。 简单得说，每当你在终端进行操作时，你都会有一个当前工作目录。
在不太确定当前位置时，就会使用pwd来判定当前目录在文件系统内的确切位置。
pwd
如果目录是链接时：
格式：pwd -P 显示出实际路径，而非使用连接（link）路径。今天这个部分有点难🚹
