Linux开发工具的使用

vim的使用

在Linux中我们有个vim工具，我们可以在它上面进行编写代码。同时vim有很多种模式。

基本模式介绍

这里我们主要介绍三种模式：命令行模式、插入模式、底行模式

当我们使用vim打开一个文件时候默认就是命令行模式，此时无论我们按什么键都写不进去，同时按Esc会变为命令行模式。

当我们按i的时候，会进入插入模式，此时我们可以进行书写代码。

当我们按Esc回到命令行模式的时候，按shift + :(冒号)进入底行模式，按wq退出vim。同时底行模式下输入：set nu显示行号

光标当前行操作

1. 复制：按两下y
2. 拷贝：然后再按p会拷贝光标所在行的内容当指定光标出。
3. n + p：拷贝n行
4. 剪贴：按两下d，然后再按p会拷贝光标所在行的内容当指定光标出。
5. 删除：按两下d
6. 撤销：按u一步一步插销步骤
7. 反撤销：ctrl + r，退回到撤销的上一步
8. x : 删除当前光标位置的字符
9. n + x：删除当前位置往后n个字符，包括当前字符
10. shif + x：删除当前光标位置前一个字符
11. n + shif + x：删除当前光标位置前n个字符，不包括当前字符

光标快速定位（命令行模式）：

1. 上下左右箭头，控制上下左右移动
2. hjkL，也可以控制上下左右移动
3. shif + g：定位到文件末尾
4. 按两下g：定位到文件开头
5. n + shif + g ：定位到第n行
6. shif + ^：定位到当前行开头
7. shif + $：定位到当前行末尾
8. b：一个单词一个单词后前走
9. w：一个单词一个单词后后走

插入模式的三种方式（命令行模式）：

• 输入a - 往后移动一个光标位置
• 输入i - 定位到当前位置
• 输入o - 往下空出一行并且光标移动到空行开头

vim基本操作（命令行模式）

1. ctrl + f：往下翻动一页
2. ctrl+b：往上翻动一页

3. shift + ~：切换大小写（小->大，大->小），同时切换之后往后移动一个字符。
4. n + shift + ~：默认往后切换n个字符的大小写。
5. r ：替换光标当前位置的字符
6. n + r：往后替换n个字符
7. shift + r：切换为替换模式，一直往后替换，直到Esc返回命令行模式。
8. vim 开多窗口

当我们使用vim打开一个窗口之后，切换到底行模式之后，输入：vs + 另一个文件名就可以再开一个窗口了。按住ctrl + ww，光标切换到下一个窗口。

9. sudo提权

同时学了vim之后我们可以再来弥补一下之前残留的一个问题，当我们是普通用户的时候，我们可以使用sudo进行短暂的提权，使我们可以使用root的权限。

底行模式的操作

1. w : 表示保存。
2. q ：表示退出
3. wq：保存并退出
4. q!：强制退出
5. wq!：强制保存并退出
6. / + 内容：定位文件内容，同时按n表示往下查找

Linux编译器 - gcc/g++的使用

这里以C语言文件为例，一个C语言源文件变为可执行程序经过了哪些步骤呢？这里我们有一个test.c源文件。

预处理 - 宏展开、取消注释等等

gcc -E test.c -o test.i

编译 - 生成汇编代码，进行语法检查。

gcc -S test.i -o test.s

汇编 - 把汇编代码翻译为机器代码

gcc -c test.s -o test.o

链接 - 生成可执行文件，进入链接

gcc test.o -o test

这里链接的时候就需要了解一下函数库了，在上述文件当中我们使用了printf这个库函数，那么这个库函数就在我们的函数库当中。

函数库一般分为静态库和动态库

1. 动态库

在Windows系统中动态库后缀为.dll，Linux（.so），当我们使用printf的时候，我们其实存储的是printf在动态库中的地址，有了这个地址我们链接的时候直接去对应的动态库中查找即可。这样做的好处就是节省了空间，但是由于每一个库函数依赖的都是我们动态库里面的，如果动态库里面的文件损坏了，那么程序就不能运行

2. 静态库

静态库则是把printf库函数的实现包了进来，这样缺点就是空间消耗大，就没有动态库那样，一个损坏其他的不能运行。

同时在Linux中有ldd命令 + 可执行程序可以查看调用了哪些动态库，Linux默认使用的是动态库。file + 可执行程序可以查看链接的时候用的是动态库还是静态库。

gcc test.c -o test -static

上述可以使用静态库。

Linux自动化构造工具 - make/makefile的使用

make：一条指令

makefile：一个文件

用法：

如上图，我们通过创建一个Makefile文件（这里的M小写也可以）和使用make指令，可以自动化帮我们执行编译与清理的工作。这就是make/makefile的作用。

来解释一下我们的Makefile：

# 这里主要是 proc 和 proc.c 的依赖关系，我们如何得到proc呢？依赖的是proc.c，那proc.c如果变为proc呢?
# 靠的是我们下面所写的依赖方法。
proc:proc.c# proc - 目标文件（可执行程序）                    # proc.c 生成proc所依赖的目标文件
[Tab]gcc proc.c -o proc  # 依赖方法                                                                         

当我们使用make指令的时候他会去Makefile文件从上往下查找，当找到第一个目标二年级四年的时候，会看后面所依赖的文件，调用依赖方法中的指令生成所需要的目标文件。

# phony有虚假的意思
# .PHONY:clean // .PHONY表示的是一种伪目标文件，而这个伪目标文件依赖的是什么呢？依赖的是clean
.PHONY:clean
# clean：clean后没有依赖目标，直接调用依赖方法中的指令即可。
clean:
[Tab] rm -f proc    

取消指令回显

如上图，当我们在编译与清理过程增加指示的时候发现不仅我们的结果输出出来，而且我们的指令也跟着显示了出来。如果我们不想要显示对应的指令只需要在Makefile文件当中对应的指令前面增加@

make/makefile使用注意事项（基本原理）：

如果我们把.PHONY放到文件开始会怎样呢？

如上图，我们发现当我们把**.PHONY放在文件开头的时候**，我们使用make指令，默认直接调用的是清理资源的指令，而我们的编译指令还需要我们使用make + proc才可以执行。

那么我们可以得出来第一条注意事项就是：

1. make/makefile有一个缺省的执行程序，就是我们Makefile从上往下查找到的第一个目标文件，其余所需要的目标文件都要使用make + 目标文件名。

那如果我们的proc.c文件中有报错呢？

如上图我们可以得出第二条注意事项：

2. 当我们make/makefile中途遇到错误的时候会直接终止程序，下面的代码不再执行

在使用make指令的时候我们发现一个问题（如下图）：

我们发现当我们使用make指令之后再进行make，我们发现并不能进行编译了？这时为什么呢？

如上图，我们发现当我们使用,.PHONY修饰我们的proc的时候，此时生成可执行文件之后再使用make又可以继续进行编译了？

这里我们就要提一个概念了，我们一个文件当中，其实有三种时间：（Access）访问时间，(Modify)修改时间，(Change)改变时间

如上图可以看到，当我们对文件内容进行修改的时候，那么文件的修改时间和改变时间都发生了变化，此时我们就可以再进行编译了，之所以之前不能进行编译的原因就在于我们的时间并没有发生改变，那么编译器如何知道我们文件的时间是否改变了呢？

如上图，当我们对文件进行修改的时候，我们文件修改的时间肯定比之前可执行程序的修改时间要晚，那么当我们修改文件之后使用make指令，编译器就会对比这两个时间，如果我们源文件的时间晚于我们的可执行程序就说明发生了修改，那么此时我们就需要再次编译否则就不能进行再编译。那上述我们加了.PHONY可以再编译的原因就是.PHONY会让编译器忽略这个时间差异，每次都当做是修改了文件来处理。

所以这里我们的第三条注意事项为：

3. .PHONY会让编译器忽略文件时间的差异

在我们上文提到一个源文件生成可执行程序需要进过预处理，编译，汇编，链接过程，那么我们试试使用makefile把这些步骤通过一个make指令自动执行试试。

如上图，我们的第四条注意事项是：

4. 当我们有多个目标文件时，我们会一个一个去查找直到找到了所依赖的文件存在的时候，才会去执行对应的指令，如果没有遇到则会有一个辅助栈依次存储对应的指令。

当然了，正常情况我们肯定不会向上面一样去写Makefile文件，我们会只保留生成.o文件和可执行程序的部分。如下：

但是此时我们还有一种写法：

这里我们第五条注意事项：

5. Makefile中可以定义变量，只不过这个变量是没有类型的！！！！！，同时定义变量的方式空格必须紧挨着变量

现在来解释一下上述代码：

bin=proc # 定义目标文件
src=proc.o  定义依赖文件                                                                                                                                                                                        $(bin):$(src)   # (bin) 可以看做是上述变量的地址 $(bin)就是上述定义的变量gcc $^ -o $@   # $@ 代表着目标文件（$(bin)）# $^ 代表的是我们所依赖的目标文件列表，就是我们依赖目标文件可以传多个。%.o:%.c  # %.c代表着通配符，只要是.c为后缀的都可以传入，代表着.c文件生成同名的.o文件gcc -c $<# $< 表示接受的.c文件列表，如果我们传入了 proc1.c，proc2.c，proc3.c#本质上是生成：#			gcc -c proc1.c#			gcc -c proc2.c#			gcc -c proc3.c
.PHONY:clean
clean:rm -f $(src) $(bin)

那如果有两个.c文件需要编译呢？

如上图，我们第六条注意事项为：

6. makefile默认只能形成一个目标文件。

那么此时如何做呢？如下图：

当然最后我们也可以生成同一个可执行程序，只需要把$(bin2)的依赖关系去掉，然后在$(bin1)后的所依赖目标把$(src2)加上即可。

总结make/makefile

好，make/makefile我们就讲到这里，我们来总一下我们所说过的5条注意事项：

1. make/makefile有一个缺省的执行程序，就是我们Makefile从上往下查找到的第一个目标文件，其余所需要的目标文件都要使用make + 目标文件名。

2. 当我们make/makefile中途遇到错误的时候会直接终止程序，下面的代码不再执行

3. .PHONY会让编译器忽略文件时间的差异

4. 当我们有多个目标文件时，我们会一个一个去查找直到找到了所依赖的文件存在的时候，才会去执行对应的指令，如果没有遇到则会有一个辅助栈依次存储对应的指令。

5. Makefile中可以定义变量，只不过这个变量是没有类型的！！！！！，同时定义变量的方式空格必须紧挨着变量

6. makefile默认只能形成一个目标文件。

进度条实现

那么有了上面的基础，我们可以使用Linux来实现一下进度条了，来看一下效果实现图：

在实现进度条之前我们有两个预备知识需要了解一下：

1. 回车与换行

在C语言当中\n表示换行，但是C语言特殊处理过，\n表示效果为回车 + 换行。\r表示只回车

2. 输出缓冲区

这里也不做过多的了解，只需举个例子即可。

如上图，在那两秒中我们的"hello Linux"到哪去了呢？其实就是到我们的输出缓冲区里面去了。而我们的’\n’可以强制刷新缓冲区。这里就需要使用fflush(FILE* stream)强制刷新缓冲区了。

C语言默认会打开三个流：stdin（标准输入流），stdout（标准输出），stderr（标准错误流）。而我们输出缓冲区就是我们的屏幕，所以我们只需要刷新stdout即可。

有了上面两个知识预备我们就可以来实现进度条了。

代码实现：

上述进度条只是我们的第一种，其实在实践当中我们一般都是登录界面会进行加载，那么这个加载的进度应该是跟我们加载了多少有关，而不是像上面那样固定的，所以我们实现第二个版本。

代码实现：

git的使用 （代码管理）

git是一种分布式多版本控制器，它可以支持多人协作，共同管理同一个项目。一下示例仓库都在gitee这个网站上方。这里我们只是为了管理我们的代码，所以只讲解基本的三板斧。

1. git clone - 把远端仓库拷贝到本地

git clone + 仓库地址

2. git add 把代码提交到暂存区

git add + 文件名，git add . 可以提交当前目录下所有文件。

3. git commit -m “提交日志” - 把暂存区的提交到本地仓库

但是由于第一次使用git需要配置用户名和邮箱地址，直接把对应指令粘下来然后输入自己的即可。

4. git push

把本地仓库的代码同步到远程的服务器上（gitee）

同时我们git可以支持windows和Linux不同系统操作同一个仓库，只不过在不同系统提交之后，在另一个系统需要使用git pull来更新不同系统的本地仓库，不然会有冲突导致提交不上去。

我们也可以使用git log 来检查我们所有的提交记录，我们的commit信息也可以看到。