深入带你了解Linux环境基础开发工具的使用（yum、vim、gcc、g++、gdb、make/Makefile）

本专栏内容为：Linux学习专栏，分为系统和网络两部分。 通过本专栏的深入学习，你可以了解并掌握Linux。

💓博主csdn个人主页：小小unicorn
⏩专栏分类：linux
🚚代码仓库：小小unicorn的代码仓库🚚
🌹🌹🌹关注我带你学习编程知识

Linux软件包管理器 - yum

Linux下安装软件的方式

在Linux下安装软件的方法大概有以下三种：
1）下载到程序的源代码，自行进行编译，得到可执行程序。
2）获取rpm安装包，通过rpm命令进行安装。（未解决软件的依赖关系）
3）通过yum进行安装软件。（常用）

认识yum

yum是一个在Fedora、RedHat以及CentOS中的前端软件包管理器，能够从指定的服务器自动下载RPM包并且安装，可以自动处理依赖性关系，并且一次安装所有依赖的软件包，无须繁琐地一次次下载、安装。

注意：一个服务器同一时刻只允许一个yum进行安装，不能在同一时刻同时安装多个软件。

因为yum是从服务器上下载RPM包，所以在下载时必须联网，可以通过ping指令判断当前云服务器是否联网。

查找软件包

[zhongjiabin@VM-16-2-centos lesson5]$ yum list

使用yum list指令，可以罗列出可供下载的全部软件。

说明一下：
1）软件包名称：主版本号.次版本号.源程序发行号-软件包的发行号.主机平台.cpu架构。
2）"x86_64"后缀表示64位系统的安装包，"i686"后缀表示32位系统安装包，选择包时要和系统匹配。
3）"el7"表示操作系统发行版的版本，“el7"表示的是"centos7/redhat7”，“el6"表示"centos6/redhat6”。
4）最后一列表示的是“软件源”的名称，类似于“小米应用商店”，“华为应用商店”这样的概念。

这里我们以查找lrzsz为例。

lrzsz可以将Windows当中的文件上传到Linux当中，也可以将Linux当中的文件下载到Windows当中，实现云服务器和本地机器之间进行信息互传。

[zhongjiabin@VM-16-2-centos lesson5]$ yum list | grep lrzsz

由于包的数量非常多，所以我们可以使用grep指令筛选出我们所关注的包，这里我们以lrzsz为例

此时就只会显示与lrzsz相关的软件包。

安装软件

指令： sudo yum install 软件名

[zhongjiabin@VM-16-2-centos lesson5]$ sudo yum install lrzsz

yum会自动找到都有哪些软件包需要下载，这时候敲“y”确认安装，当出现“complete”字样时，说明安装完成。
注意事项：
1）安装软件时由于需要向系统目录中写入内容，一般需要sudo或者切换到root账户下才能完成。
2）yum安装软件只能一个装完了再装另一个，正在使用yum安装一个软件的过程中，如果再尝试用yum安装另外一个软件，yum会报错。

如何实现本地机器和云服务器之间的文件互传

既然已经安装了lrzsz，这里就顺便说一下lrzsz如何使用。
指令： rz -E
通过该指令可选择需要从本地机器上传到云服务器的文件。

指令： sz 文件名
该指令可将云服务器上的文件下载到本地机器的指定文件夹。

卸载软件

指令： sudo yum remove 软件名

[zhongjiabin@VM-16-2-centos linux]$ sudo yum remove lrzsz

Linux编辑器 - vim

vim的基本概念

vim在我们做开发的时候，主要解决我们编写代码的问题，本质上就是一个多模式的文本编辑器。

我们这里主要介绍vim最常用的三种模式：命令模式、插入模式、底行模式。
1、命令模式（Normal mode）。
在命令模式下，我们可以控制屏幕光标的移动，字符、字或行的删除，复制粘贴，剪贴等操作。
2、插入模式（Insert mode）。
只有在插入模式下才能进行文字输入，该模式是我们使用最频繁的编辑模式。
3、底行模式（Command mode）。
在底行模式下，我们可以将文件保存或退出，也可以进行查找字符串等操作。在底行模式下我们还可以直接输入vim help-modes查看当前vim的所有模式。

vim下各模式的切换

指令： vim 文件名

[zhongjiabin@VM-16-2-centos lesson5]$ vim test.c

进入vim后默认为命令模式（普通模式），要输入文字需切换到插入模式。

【命令模式】切换至【插入模式】
1）输入「i」：在当前光标处进入插入模式。
2）输入「a」：在当前光标的后一位置进入插入模式。
3）输入「o」：在当前光标处新起一行进入插入模式。

【命令模式】切换至【底行模式】
1）输入「Shift+;」即可，实际上就是输入「:」。

【插入模式】或【底行模式】切换至【命令模式】
1）插入模式或是底行模式切换至命令模式都是直接按一下「Esc」键即可。

vim命令模式各命令汇总

【移动光标】
1）按「k」：光标上移。
2）按「j」：光标下移。
3）按「h」：光标左移。
4）按「l」：光标右移。
5）按「$」：移动到光标所在行的行尾。
6）按「^」：移动到光标所在行的行首。
7）按「gg」：移动到文本开始。
8）按「Shift+g」：移动到文本末尾。
9）按「n+Shift+g」：移动到第n行行首。
10）按「n+Enter」：当前光标向下移动n行。
11）按「w」：光标从左到右，从上到下的跳到下一个字的开头。
12）按「e」：光标从左到右，从上到下的跳到下一个字的结尾。
12）按「b」：光标从右到左，从下到上的跳到上一个字的开头
【删除】
1）按「x」：删除光标所在位置的字符。
2）按「nx」：删除光标所在位置开始往后的n个字符。
3）按「X」：删除光标所在位置的前一个字符。
4）按「nX」：删除光标所在位置的前n个字符。
5）按「dd」：删除光标所在行。
6）按「ndd」：删除光标所在行开始往下的n行。
【复制粘贴】
1）按「yy」：复制光标所在行到缓冲区。
2）按「nyy」：复制光标所在行开始往下的n行到缓冲区。
3）按「yw」：将光标所在位置开始到字尾的字符复制到缓冲区。
4）按「nyw」：将光标所在位置开始往后的n个字复制到缓冲区。
5）按「p」：将已复制的内容在光标的下一行粘贴上。
6）按「np」：将已复制的内容在光标的下一行粘贴n次。
【剪切】
1）按「dd」：剪切光标所在行。
2）按「ndd」：剪切光标所在行开始往下的n行。
3）按「p」：将已剪切的内容在光标的下一行粘贴上。
4）按「np」：将已剪切的内容在光标的下一行粘贴n次。
【撤销】
1）按「u」：撤销。
2）按「Ctrl+r」：恢复刚刚的撤销。
【大小写切换】
1）按「~」：完成光标所在位置字符的大小写切换。
2）按「n~」：完成光标所在位置开始往后的n个字符的大小写切换。
【替换】
1）按「r」：替换光标所在位置的字符。
2）按「R」：替换光标所到位置的字符，直到按下「Esc」键为止。
【更改】
1）按「cw」：将光标所在位置开始到字尾的字符删除，并进入插入模式。
2）按「cnw」：将光标所在位置开始往后的n个字删除，并进入插入模式。
【翻页】
1）按「Ctrl+b」：上翻一页。
2）按「Ctrl+f」：下翻一页。
3）按「Ctrl+u」：上翻半页。
4）按「Ctrl+d」：下翻半页。

vim底行模式各命令汇总

在使用底行模式之前，记住先按「Esc」键确定你已经处于命令模式，再按「:」即可进入底行模式。

【行号设置】
1）「set nu」：显示行号。
2）「set nonu」：取消行号。
【保存退出】
1）「w」：保存文件。
2）「q」：退出vim，如果无法离开vim，可在「q」后面跟一个「!」表示强制退出。
3）「wq」：保存退出。
【分屏指令】
1）「vs 文件名」：实现多文件的编辑。
2）「Ctrl+w+w」：光标在多屏幕下进行切换。
【执行指令】
1）「!+指令」：在不退出vim的情况下，可以在指令前面加上「!」就可以执行Linux的指令，例如查看目录、编译当前代码等。

vim的简单配置

【配置文件的位置】
1）在目录/etc/下面，有个名为vimrc的文件，这是系统中公共的配置文件，对所有用户都有效。
2）在每个用户的主目录/home/xxx下，都可以自己建立私有的配置文件，命名为“.vimrc”，这是该用户私有的配置文件，仅对该用户有效。

例如，普通用户在自己的主目录下建立了“.vimrc”文件后，在文件当中输入set nu指令并保存，下一次打开vim的时候就会自动显示行号。

vim的配置比较复杂，某些vim配置还需要使用插件，建议不要自己一个个去配置。比较简单的方法是直接执行以下指令（想在哪个用户下让vim配置生效，就在哪个用户下执行该指令，不推荐直接在root下执行）：

curl -sLf https://gitee.com/HGtz2222/VimForCpp/raw/master/install.sh -o ./install.sh && bash ./install.sh

然后按照提示输入root密码：

然后等待安装配置，最后手动执行source ~/.bashrc即可。

Linux编译器 - gcc/g++

背景知识

我们来讲解一下什么是动态，什么是静态链接：
假设你是小明，你初中学习很努力，考上了一所不错的高中，但是呢，这个高中不允许你带任何电子产品，这对你来说很苦恼，因此呢，你在正式开学前，就联系到了你的学长，学长告诉你说，哎呀，不用慌，你出学校右拐，有一个网吧，这个网吧价格便宜，性价比很高。好，这下你就知道了。

每一次你就偷偷的溜出去和你的舍友去上网，其乐融融，但是突然，有一天，警察来了，一查这个网吧，发现竟然没有营业执照，呕吼，网吧不得不停止营业。而这里的网吧我们就是一个动态库，他里面的东西，电脑都是共享的，但是当这个网吧倒闭了后，就会影响一些人，包括你。所以动态库不能缺失，一旦对应的动态库缺失，影响的就不单单是一个程序，跟你一样，你上不了网，但你隔壁宿舍的张三李四也上不了网了。

说完动态，我们来说静态。
这个老板不长记性，他呢 ，又在你的学校隔壁开了家店，但是他现在学聪明了，他不开网吧，他开了个二手电脑销售店，价格实惠。哇，你一听，这不机会又来了，于是你屁颠屁颠的跑去买了一台，放在你的宿舍的角落里，这次你不用 去网吧，你直接在宿舍，等着凌晨就跟着隔壁的张三就开始战斗。突然有一天呢，你得到小道消息，说那个卖二手电脑的老板有被警察抓了。但是呢，这次老板被抓，依然影响不到你晚上继续跟张三开黑，因为电脑就在你的宿舍。而这个二手电脑销售上就可以理解为我们的静态库。所以静态库的特点的就是，它在进行静态链接的时候，会将自己的方法拷贝到目标程序中，该程序以后不用在依赖静态库~！

这里我们最好建议大家将我们的c和c++的静态库安装上~

sudo yum install -y glibc-static
sudo yum install -y libstdc++-static

gcc/g++的作用

gcc和g++分别是GNU的C和C++的编译器，gcc和g++在执行编译的时候一般有以下四个步骤：
1）预处理（头文件展开、去注释、宏替换、条件编译）。
2）编译（C代码翻译成汇编语言）。
3）汇编（汇编代码转为二进制目标代码）。
4）链接（将汇编过程产生的二进制代码进行链接）。

gcc/g++语法

语法： gcc/g++ 选项 文件

常用选项：
1）-E 只进行预处理，这个不生成文件，你需要把他重定向到一个输出文件里面（否则将把预处理后的结果打印到屏幕上）。
2）-S 编译到汇编语言，不进行汇编和链接，即只进行预处理和编译。
3）-c 编译到目标代码
4）-o 将处理结果输出到指定文件，该选项后需紧跟输出文件名。
5）-static 此选项对生成的文件采用静态链接。
6）-g 生成调试信息（若不携带该选项则默认生成release版本）。
7）-shared 此选项将尽量使用动态库，生成文件较小。
8）-w 不生成任何警告信息。
9）Wall 生成所有警告信息。
10）-O0/-O1/-O2/-O3 编译器优化选项的四个级别，-O0表示没有优化，-O1为缺省值，-O3优化级别最高。

预处理

[zhongjiabin@VM-16-2-centos lesson5]$  gcc -E test.c -o test.i

1. 预处理功能主要包括头文件展开、去注释、宏替换、条件编译等。
2. 预处理指令是以#开头的代码行。
3. -E选项的作用是让gcc/g++在预处理结束后停止编译过程。
4. -o选项是指目标文件，“xxx.i”文件为已经过预处理的原始程序。

编译

[zhongjiabin@VM-16-2-centos lesson5]$  gcc -E test.c -o test.i

1. 在这个阶段中，gcc/g++首先检查代码的规范性、是否有语法错误等，以确定代码的实际要做的工作，在检查无误后，将代码翻译成汇编语言。
2. 用户可以使用-S选项来进行查看，该选项只进行编译而不进行汇编，生成汇编代码。
3. o选项是指目标文件，“xxx.s”文件为已经过翻译的原始程序。

汇编

[zhongjiabin@VM-16-2-centos lesson5]$ gcc -c test.s -o test.o

1. 汇编阶段是把编译阶段生成的“xxx.s”文件转成目标文件。
2. 使用-c选项就可以得到汇编代码转化为“xxx.o”的二进制目标代码了。
   
   

链接

[zhongjiabin@VM-16-2-centos lesson5]$ gcc test.o -o test

1. 在成功完成以上步骤之后，就进入了链接阶段。
2. 链接的主要任务就是将生成的各个“xxx.o”文件进行链接，生成可执行文件。
3. gcc/g++不带-E、-S、-c选项时，就默认生成预处理、编译、汇编、链接全过程后的文件。
4. 若不用-o选项指定生成文件的文件名，则默认生成的可执行文件名为a.out。

注意： 链接后生成的也是二进制文件。

静态库与动态库

函数库一般分为静态库和动态库两种：

1. 静态库是指编译链接时，把库文件的代码全部加入到可执行文件当中，因此生成的文件比较大，但在运行时也就不再需要库文件了，静态库一般以.a为后缀。
2. 动态库与之相反，在编译链接时并没有把库文件的代码加入到可执行文件当中，而是在程序运行时由链接文件加载库，这样可以节省系统的开销，动态库一般以.so为后缀。

动态链接：
 优点：省空间（磁盘的空间，内存的空间），bin体积小，加载速度快。
 缺点：依赖动态库，程序可移植性较差。

静态链接：
 优点：不依赖第三方库，程序的可移植性较高。
 缺点：浪费空间。

gcc和g++默认生成的二进制程序是动态链接的，我们可以使用file指令进行查看。

其次，我们还可以使用ldd指令查看动态链接的可执行文件所依赖的库。

（图中的/lib64/libc.so.6就是当前云服务器当中的C标准库）。

虽然gcc和g++默认采用的是动态链接，但如果我们需要使用静态链接，带上-static选项即可。

我们可以查看源代码相同，但链接方式不同而生成的两个可执行程序test和test_s的大小。

这也证明了动态链接比较节省空间，而静态链接比较浪费空间。

Linux调试器 - gdb

gdb使用须知

程序发布方式：
 1、debug版本：程序本身会被加入更多的调试信息，以便于进行调试。
 2、release版本：不会添加任何调试信息，是不可调试的。

在Linux当中gcc/g++默认生成的可执行程序是release版本的，是不可被调试的。如果想生成debug版本，就需要在使用gcc/g++生成可执行程序时加上-g选项。

对同一份源代码分别生成其release版本和debug版本的可执行程序，并通过ll指令可以看到，debug版本发布的可执行程序的大小比release版本发布的可执行程序的大小要大一点，其原因就是以debug版本发布的可执行程序当中包含了更多的调试信息。

gdb命令汇总

【进入gdb】
指令： gdb 文件名

【调试】
1）「run/r」：运行代码（启动调试）。
2）「next/n」：逐过程调试。
3）「step/s」：逐语句调试。
4）「until 行号」：跳转至指定行。
5）「finish」：执行完当前正在调用的函数后停下来（不能是主函数）。
6）「continue/c」：运行到下一个断点处。
7）「set var 变量=x」：修改变量的值为x。

【显示】
1）「list/l n」：显示从第n行开始的源代码，每次显示10行，若n未给出则默认从上次的位置往下显示.。
2）「list/l 函数名」：显示该函数的源代码。
3）「print/p 变量」：打印变量的值。
4）「print/p &变量」：打印变量的地址。
5）「print/p 表达式」：打印表达式的值，通过表达式可以修改变量的值。
6）「display 变量」：将变量加入常显示（每次停下来都显示它的值）。
7）「display &变量」：将变量的地址加入常显示。
8）「undisplay 编号」：取消指定编号变量的常显示。
9）「bt」：查看各级函数调用及参数。
10）「info/i locals」：查看当前栈帧当中局部变量的值。

【断点】
1）「break/b n」：在第n行设置断点。
2）「break/b 函数名」：在某函数体内第一行设置断点。
3）「info breakpoint/b」：查看已打断点信息。
4）「delete/d 编号」：删除指定编号的断点。
5）「disable 编号」：禁用指定编号的断点。
6）「enable 编号」：启用指定编号的断点。

【退出gdb】
1）「quit/q」：退出gdb。

Linux项目自动化构建工具 - make/Makefile

make/Makefile的重要性

1. 会不会写Makefile，从侧面说明了一个人是否具备完成大型工程的能力。
2. 一个工程的源文件不计其数，按照其类型、功能、模块分别放在若干个目录当中，Makefile定义了一系列的规则来指定：哪些文件需要先编译，哪些文件需要后编译，甚至于进行更复杂的功能操作。
3. Makefile带来的好处就是“自动化编译”，一旦写好，只需一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。
4. mak是一个命令工具，是一个解释Makefile当中指令的命令工具，一般来说，大多数的IDE都有这个命令，例如：Delphi的make，Visual
   C++的nmake，Linux下GNU的make。可见，Makefile都成为了一种在工程方面的编译方法。
5. make是一条命令，Makefile是一个文件，两个搭配使用，完成项目自动化构建。

依赖关系和依赖方法

在使用make/Makefile前我们首先应该理解各个文件之间的依赖关系以及它们之间的依赖方法。

依赖关系： 文件A的变更会影响到文件B，那么就称文件B依赖于文件A。

例如，test.o文件是由test.c文件通过预处理、编译以及汇编之后生成的文件，所以test.c文件的改变会影响test.o，所以说test.o文件依赖于test.c文件。
依赖方法： 如果文件B依赖于文件A，那么通过文件A得到文件B的方法，就是文件B依赖于文件A的依赖方法。

例如，test.o依赖于test.c，而test.c通过gcc -c test.c -o
test.o指令就可以得到test.o，那么test.o依赖于test.c的依赖方法就是gcc -c test.c -o test.o。

多文件编译

当你的工程当中有多个源文件的时候，应该如何进行编译生成可执行程序呢？

首先，我们可以直接使用gcc指令对多个源文件进行编译，进而生成可执行程序。

但进行多文件编译的时候一般不使用源文件直接生成可执行程序，而是先用每个源文件各自生成自己的二进制文件，然后再将这些二进制文件通过链接生成可执行程序。

原因：

若是直接使用源文件生成可执行程序，那么其中一个源文件进行了修改，再生成可执行程序的时候就需要将所以的源文件重新进行编译链接。

而若是先用每个源文件各自生成自己的二进制文件，那么其中一个源文件进行了修改，就只需重新编译生成该源文件的二进制文件，然后再将这些二进制文件通过链接生成可执行程序即可。
注意： 编译链接的时候不需要加上头文件，因为编译器通过源文件的内容可以知道所需的头文件名字，而通过头文件的包含方式（“尖括号”包含和“双引号”包含），编译器可以知道应该从何处去寻找所需头文件。

但是随着源文件个数的增加，我们每次重新生成可执行程序时，所需输入的gcc指令的长度与个数也会随之增加。这时我们就需要使用make和Makefile了，这将大大减少我们的工作量。

步骤一： 在源文件所在目录下创建一个名为Makefile/makefile的文件。

步骤二： 编写Makefile文件。
Makefile文件最简单的编写格式是，先写出文件的依赖关系，然后写出这些文件之间的依赖方法，依次写下去。

编写完毕Makefile文件后保存退出，然后在命令行当中执行make指令便可以生成可执行程序，以及该过程产生的中间产物。

Makefile文件的简写方式：

$@：表示依赖关系中的目标文件（冒号左侧）。
$^：表示依赖关系中的依赖文件列表（冒号右侧全部）。
$<：表示依赖关系中的第一个依赖文件（冒号右侧第一个）。

例如以上Makefile文件可以简写为：

说明： gcc/g++携带-c选项时，若不指定输出文件的文件名，则默认输出文件名为xxx.o，所以这里也可以不用指定输出文件名。

make原理

1. make会在当前目录下找名字为“Makefile”或“makefile”的文件。
2. 如果找到，它会找文件当中的第一个目标文件，在上面的例子中，它会找到mytest这个文件，并把这个文件作为最终的目标文件。
3. 如果mytest文件不存在，或是mytest所依赖的后面的test.o文件和main.o文件的文件修改时间比mytest文件新，那么它就会执行后面的依赖方法来生成mytest文件。
4. 如果mytest所依赖的test.o文件不存在，那么make会在Makefile文件中寻找目标为test.o文件的依赖关系，如果找到则再根据其依赖方法生成test.o文件（类似于堆栈的过程）。
5. 当然，你的test.c文件和main.c文件是存在的，于是make会生成test.o文件和main.o文件，然后再用test.o文件和main.o文件生成最终的mytest文件。
6. make会一层又一层地去找文件的依赖关系，直到最终编译出第一个目标文件。
7. 在寻找的过程中，如果出现错误，例如最后被依赖的文件找不到，那么make就会直接退出，并报错。

项目清理

在我们每次重新生成可执行程序前，都应该将上一次生成可执行程序时生成的一系列文件进行清理，但是如果我们每次都手动执行一系列指令进行清理工作的话，未免有些麻烦，因为每次清理时执行的都是相同的清理指令，这时我们可以将项目清理的指令也加入到Makefile文件当中。

像clean这种，没有被第一个目标文件直接或间接关联，那么它后面所定义的命令将不会被自动执行，但我们可以显示要make执行。

注： 一般将这种clean的目标文件设置为伪目标，用.PHONY修饰，伪目标的特性是：总是被执行。

Linux第一个小程序 - 进度条

行缓冲区的概念

首先，我们来感受一下行缓冲区的存在，在Linux当中以下代码的运行结果是什么样的？

对于此代码，大家应该都没问题，当然是先输出字符串hello world然后休眠3秒之后结束运行。那么对于以下代码呢？

可以看到代码中仅仅删除了字符串后面的’\n’，那么代码的运行结果还与之前相同吗？答案否定的，该代码的运行结果是：先休眠3秒，然后打印字符串hello linux之后结束运行。该现象就证明了行缓冲区的存在。

显示器对应的是行刷新，即当缓冲区当中遇到’\n’或是缓冲区被写满才会被打印出来，而在第二份代码当中并没有’\n’，所以字符串hello linux先被写到缓冲区当中去了，然后休眠3秒后，直到程序运行结束时才将hello linux打印到显示器当中。

\r和\n

\r： 回车，使光标回到本行行首。
\n： 换行，使光标下移一格。

而我们键盘上的Enter键实际上就等价于\n+\r。

既然是\r是使光标回到本行行首，那么如果我们向显示器上写了一个数之后再让光标回到本行行首，然后再写一个数，不就相当于将前面一个数字覆盖了吗？

但这里有一个问题：不使用’\n’进行换行怎么将缓冲区当中数据打印出来？
这里我们可以使用fflush函数，该函数可以刷新缓冲区，即将缓冲区当中的数据刷新当显示器当中。
对此我们可以编写一个倒计时的程序。

在输出下一个数之前都让光标先回到本行行首，就得到了倒计时的效果。

进度条代码及效果展示

知道了\r这个概念我们就可以实现一个简单的进度条了。

首先在目录下创建一下文件：

版本一：

Makefile：

process:process.c main.cgcc -o $@ $^
.PHONY:clean
clean:rm -f process

process.h

#pragma once #include<stdio.h>void process();

process.c

#include"process.h"
#include<string.h>
#include<unistd.h>
#include<stdlib.h>
#define SIZE 101
#define MAX_RATR 100
#define STYLE '#'
#define STIME 1000*200
const char *str="|/-\\";
void process()
{//version1int rate=0;char bar[SIZE];memset(bar,'\0',sizeof(bar));int num=strlen(str);while(rate<=MAX_RATR){printf("[%-100s][%d%%][%c]\r",bar,rate,str[rate%num]);fflush(stdout);usleep(STIME);bar[rate++]=STYLE;}printf("\n");
}

main.c

#include"process.h"int main()
{process();return 0;
}

运行结果：

版本二：

Makefile：

process:process.c main.cgcc -o $@ $^
.PHONY:clean
clean:rm -f process

process.h

#pragma once #include<stdio.h>void process();

process.c

#include"process.h"
#include<string.h>
#include<unistd.h>
#include<stdlib.h>#define SIZE 101
#define MAX_RATR 100
#define STYLE '#'
#define STIME 1000*200const char *str="|/-\\";void process()
{//version1int rate=0;char bar[SIZE];memset(bar,'\0',sizeof(bar));int num=strlen(str);while(rate<=MAX_RATR){printf("\033[%d;%dm[%-100s]\033[0m\033[40;%dm[%d%%]\033[0m\033[40;%dm[%c]\033[0m\r",rand()%10+40,rand()%10+30,bar, rand()%10+30,rate,rand()%10+30, str[rate%num]);//printf("[%-100s][%d%%][%c]\r",bar,rate,str[rate%num]);fflush(stdout);usleep(STIME);bar[rate++]=STYLE;}printf("\n");
}

main.c

#include"process.h"int main()
{process();return 0;
}

运行结果：

版本3

当然，上面的进度条是’#'的方式体现的，我们还可以将它改为箭头：

makefile

ProcessBar:ProcessBar.c main.cgcc -o $@ $^
.PHONY:clean
clean:rm -f ProcessBar

ProcessBar.c

#include "ProcessBar.h"
#include <string.h>#define SIZE 101         // 定义进度条的大小为 101（用于表示 100% 的进度和一个终止字符）
#define MAX_RATR 100     // 最大的进度比例，设置为 100
#define STYLE '*'        // 进度条的显示字符，这里选择的是 #
#define STIME 1000 * 200 // 每次更新进度条的时间延迟，设置为 200 毫秒（1000 微秒 × 200）
#define BODY '='         // 进度条身体
#define TAIL '>'         // 进度条尾巴// 定义一个字符串，包含四个字符，用于在进度条更新时显示不同的进度指示符
const char *str = "|/-\\";void ProcessBar1()
{// version1int rate = 0;                   // 初始化进度变量 rate 为 0。char Bar[SIZE];                 // 创建一个字符数组 Bar 用于表示进度条memset(Bar, '\0', sizeof(Bar)); // 将 Bar 数组的所有元素初始化为 '\0'，即清空数组。int num = strlen(str);          // 计算字符串 str 的长度（4），用于后续的指示符更新while (rate <= MAX_RATR)        // 当进度小于等于 100 时，继续循环。{// 打印格式化的字符串//%-100s: 打印进度条，宽度为 100，左对齐//%d%%: 打印当前进度百分比  %%: 是用来打印字面上的百分号字符 %//%c: 打印当前进度指示符//\r: 回车符，使下一次输出覆盖当前行printf("[%-100s][%d%%][%c]\r", Bar, rate, str[rate % num]);// 刷新输出缓冲区，确保进度条立即显示。fflush(stdout);// 暂停程序执行一段时间（200 毫秒），用于控制更新速度。usleep(STIME);// 将当前进度位置用 # 更新，rate++ 后自增Bar[rate++] = STYLE;}printf("\n");
}
void ProcessBar2()
{// version2int rate = 0;                   // 初始化进度变量 rate 为 0。char Bar[SIZE];                 // 创建一个字符数组 Bar 用于表示进度条memset(Bar, '\0', sizeof(Bar)); // 将 Bar 数组的所有元素初始化为 '\0'，即清空数组。int num = strlen(str);          // 计算字符串 str 的长度（4），用于后续的指示符更新while (rate <= MAX_RATR)        // 当进度小于等于 100 时，继续循环。{//\033[: 开始一个 ANSI 转义序列。\033 是 ASCII 字符 27（ESC），[ 后面跟随的数字定义了颜色和格式。//%d;%d: 这里有两个 %d，它们用于随机生成背景和前景的颜色。// 第一个 %d：rand() % 10 + 40，生成一个范围在 40 到 49 之间的整数，用于背景色（40-49 是标准的 ANSI 颜色代码）。// 第二个 %d：rand() % 10 + 30，生成一个范围在 30 到 39 之间的整数，用于前景色（30-39 是标准的 ANSI 颜色代码）。//%dm 是 printf 函数中用于格式化字符串的一个占位符，通常用于指定 ANSI 转义码中的颜色或样式。// 在这个中，d代表一个整数，m用于结束颜色或样式的设置。//\033[0m: 重置所有的属性和颜色，将后续的输出恢复到默认状态。这确保了前面的颜色设置只影响了进度条的显示，而不会影响之后的输出。//\033[40;%dm[%d%%]:(显示进度百分比)// rand() % 10 + 30：用于设置前景色，显示当前进度百分比。//[%d%%]：显示当前的进度百分比，rate 是当前进度值。//\033[40;%dm[%c]:(显示进度指示符)// rand() % 10 + 30：又一次设置前景色，用于显示当前的进度指示符。//[%c]：显示当前的进度指示符，使用 str[rate % num] 来从 str 字符串中选择一个字符。printf("\033[%d;%dm[%-100s]\033[0m\033[40;%dm[%d%%]\033[0m\033[40;%dm[%c]\033[0m\r",rand() % 10 + 40, rand() % 10 + 30, Bar, rand() % 10 + 30, rate, rand() % 10 + 30, str[rate % num]);// 刷新输出缓冲区，确保进度条立即显示。fflush(stdout);// 暂停程序执行一段时间（200 毫秒），用于控制更新速度。usleep(STIME);// 将当前进度位置用 # 更新，rate++ 后自增Bar[rate++] = STYLE;}printf("\n");
}void ProcessBar3()
{// version3int rate = 0;                   // 初始化进度变量 rate 为 0。char Bar[SIZE];                 // 创建一个字符数组 Bar 用于表示进度条memset(Bar, '\0', sizeof(Bar)); // 将 Bar 数组的所有元素初始化为 '\0'，即清空数组。int num = strlen(str);          // 计算字符串 str 的长度（4），用于后续的指示符更新while (rate <= MAX_RATR)        // 当进度小于等于 100 时，继续循环。{// 打印格式化的字符串//%-100s: 打印进度条，宽度为 100，左对齐//%d%%: 打印当前进度百分比  %%: 是用来打印字面上的百分号字符 %//%c: 打印当前进度指示符//\r: 回车符，使下一次输出覆盖当前行printf("[%-100s][%d%%][%c]\r", Bar, rate, str[rate % num]);// 刷新输出缓冲区，确保进度条立即显示。fflush(stdout);// 暂停程序执行一段时间（200 毫秒），用于控制更新速度。usleep(STIME);// 将当前进度位置用 # 更新，rate++ 后自增Bar[rate++] = BODY;// 此时我们的rate在下一个位置，我们让=的下一个位置弄为>// 小心越界问题if (rate <= 100)Bar[rate] = TAIL;}printf("\n");
}
// 倒计时
void Countdown()
{int Size = 10;while (Size){printf("%-2d\r", Size);fflush(stdout);sleep(1);Size--;}// printf("hello world");
}

ProcessBar.h

#pragma once
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>// 版本1
void ProcessBar1();
// 版本2
void ProcessBar2();
// 版本3
void ProcessBar3();
// 倒计时
void Countdown();

main.c

#include "ProcessBar.h"
#include <unistd.h>int main()
{// 进度条// 版本一// ProcessBar1();// 版本二// ProcessBar2();// 版本3ProcessBar3();// 倒计时//  Countdown();return 0;
}

展示一下运行结果：

很明显这个版本的进度条比之前的好看多了。

版本4

我们为了更好的理解我们的进度条是如何被调用的，我们可以进行更改进度条版本4：

在之前的进度条版本里，我们的进度条可以说是通过循环来进行控制。

其实我们可以把这个循环抽离出来，抽离出来就是，给他一个比率，他打印多少。

接下来我们可以模拟一下实际的一个应用场景：

假设我们要下一个1000MB的东西，平常下载肯定是一点一点的下载，我们将当前值先从0开始，每次下载10MB，注意传参，我们传的是比率。

完整代码：

ProcessBar.h

#pragma once
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>// 版本1
void ProcessBar1();
// 版本2
void ProcessBar2();
// 版本3
void ProcessBar3();
// 版本4   
void ProcessBar4(int rate);
// 倒计时
void Countdown();

ProcessBar.c

#include "ProcessBar.h"
#include <string.h>#define SIZE 101         // 定义进度条的大小为 101（用于表示 100% 的进度和一个终止字符）
#define MAX_RATR 100     // 最大的进度比例，设置为 100
#define STYLE '*'        // 进度条的显示字符，这里选择的是 #
#define STIME 1000 * 200 // 每次更新进度条的时间延迟，设置为 200 毫秒（1000 微秒 × 200）
#define BODY '='         // 进度条身体
#define TAIL '>'         // 进度条尾巴char processbar[SIZE];
// 定义一个字符串，包含四个字符，用于在进度条更新时显示不同的进度指示符
const char *str = "|/-\\";void ProcessBar1()
{// version1int rate = 0;                   // 初始化进度变量 rate 为 0。char Bar[SIZE];                 // 创建一个字符数组 Bar 用于表示进度条memset(Bar, '\0', sizeof(Bar)); // 将 Bar 数组的所有元素初始化为 '\0'，即清空数组。int num = strlen(str);          // 计算字符串 str 的长度（4），用于后续的指示符更新while (rate <= MAX_RATR)        // 当进度小于等于 100 时，继续循环。{// 打印格式化的字符串//%-100s: 打印进度条，宽度为 100，左对齐//%d%%: 打印当前进度百分比  %%: 是用来打印字面上的百分号字符 %//%c: 打印当前进度指示符//\r: 回车符，使下一次输出覆盖当前行printf("[%-100s][%d%%][%c]\r", Bar, rate, str[rate % num]);// 刷新输出缓冲区，确保进度条立即显示。fflush(stdout);// 暂停程序执行一段时间（200 毫秒），用于控制更新速度。usleep(STIME);// 将当前进度位置用 # 更新，rate++ 后自增Bar[rate++] = STYLE;}printf("\n");
}
void ProcessBar2()
{// version2int rate = 0;                   // 初始化进度变量 rate 为 0。char Bar[SIZE];                 // 创建一个字符数组 Bar 用于表示进度条memset(Bar, '\0', sizeof(Bar)); // 将 Bar 数组的所有元素初始化为 '\0'，即清空数组。int num = strlen(str);          // 计算字符串 str 的长度（4），用于后续的指示符更新while (rate <= MAX_RATR)        // 当进度小于等于 100 时，继续循环。{//\033[: 开始一个 ANSI 转义序列。\033 是 ASCII 字符 27（ESC），[ 后面跟随的数字定义了颜色和格式。//%d;%d: 这里有两个 %d，它们用于随机生成背景和前景的颜色。// 第一个 %d：rand() % 10 + 40，生成一个范围在 40 到 49 之间的整数，用于背景色（40-49 是标准的 ANSI 颜色代码）。// 第二个 %d：rand() % 10 + 30，生成一个范围在 30 到 39 之间的整数，用于前景色（30-39 是标准的 ANSI 颜色代码）。//%dm 是 printf 函数中用于格式化字符串的一个占位符，通常用于指定 ANSI 转义码中的颜色或样式。// 在这个中，d代表一个整数，m用于结束颜色或样式的设置。//\033[0m: 重置所有的属性和颜色，将后续的输出恢复到默认状态。这确保了前面的颜色设置只影响了进度条的显示，而不会影响之后的输出。//\033[40;%dm[%d%%]:(显示进度百分比)// rand() % 10 + 30：用于设置前景色，显示当前进度百分比。//[%d%%]：显示当前的进度百分比，rate 是当前进度值。//\033[40;%dm[%c]:(显示进度指示符)// rand() % 10 + 30：又一次设置前景色，用于显示当前的进度指示符。//[%c]：显示当前的进度指示符，使用 str[rate % num] 来从 str 字符串中选择一个字符。printf("\033[%d;%dm[%-100s]\033[0m\033[40;%dm[%d%%]\033[0m\033[40;%dm[%c]\033[0m\r",rand() % 10 + 40, rand() % 10 + 30, Bar, rand() % 10 + 30, rate, rand() % 10 + 30, str[rate % num]);// 刷新输出缓冲区，确保进度条立即显示。fflush(stdout);// 暂停程序执行一段时间（200 毫秒），用于控制更新速度。usleep(STIME);// 将当前进度位置用 # 更新，rate++ 后自增Bar[rate++] = STYLE;}printf("\n");
}void ProcessBar3()
{// version3int rate = 0;                   // 初始化进度变量 rate 为 0。char Bar[SIZE];                 // 创建一个字符数组 Bar 用于表示进度条memset(Bar, '\0', sizeof(Bar)); // 将 Bar 数组的所有元素初始化为 '\0'，即清空数组。int num = strlen(str);          // 计算字符串 str 的长度（4），用于后续的指示符更新while (rate <= MAX_RATR)        // 当进度小于等于 100 时，继续循环。{// 打印格式化的字符串//%-100s: 打印进度条，宽度为 100，左对齐//%d%%: 打印当前进度百分比  %%: 是用来打印字面上的百分号字符 %//%c: 打印当前进度指示符//\r: 回车符，使下一次输出覆盖当前行printf("[%-100s][%d%%][%c]\r", Bar, rate, str[rate % num]);// 刷新输出缓冲区，确保进度条立即显示。fflush(stdout);// 暂停程序执行一段时间（200 毫秒），用于控制更新速度。usleep(STIME);// 将当前进度位置用 # 更新，rate++ 后自增Bar[rate++] = BODY;// 此时我们的rate在下一个位置，我们让=的下一个位置弄为>// 小心越界问题if (rate <= 100)Bar[rate] = TAIL;}printf("\n");
}void ProcessBar4(int rate)
{// 版本4// 我们重点理解一下我们的进度条是如何被调用的// 判断越界if (rate < 0 || rate > 100)return;int num = strlen(str);printf("[%-100s][%d%%][%c]\r", processbar, rate, str[rate % num]);fflush(stdout);processbar[rate++] = BODY;if (rate < 100)processbar[rate] = TAIL;
}
// 倒计时
void Countdown()
{int Size = 10;while (Size){printf("%-2d\r", Size);fflush(stdout);sleep(1);Size--;}// printf("hello world");
}

main.c

#include "ProcessBar.h"
#include <unistd.h>int main()
{// 进度条// 版本一// ProcessBar1();// 版本二// ProcessBar2();// 版本3//ProcessBar3();// 版本4// 我们模拟一下实际的应用场景：int total = 1000; // 假设我们有一个1000MB的东西int curr = 0;     // 当前下载了多少MB;while (curr <= total){ProcessBar4(curr * 100 / total);// 执行着某种下载的任务curr += 10; // 每次下载10MBusleep(50000);}printf("\n");// 倒计时//  Countdown();return 0;
}

我们看一下运行效果：

但是其实会发现，这个版本跟我们的版本一本质其实是一样的。来我们将我们的版本4在进行加工，写一份巨diao的一个进度条！！

版本5

我们将主函数里面的抽离成一个函数DownLoad。

我们让这个函数模拟我们的安装或者是下载。

// 模拟一种安装或者下载
void DownLoad()
{int total = 1000; // 假设我们有一个1000MB的东西int curr = 0;     // 当前下载了多少MB;while (curr <= total){// 执行着某种下载的任务usleep(50000);int rate = curr * 100 / total;curr += 10; // 每次下载10MB}printf("\n");
}

接下来我们定义一个函数指针类型;

typedef void (*callback_t)(int); // 函数指针类型

然后修改我们的DownLoad函数：

void DownLoad(callback_t cb)
{int total = 1000; // 假设我们有一个1000MB的东西int curr = 0;     // 当前下载了多少MB;while (curr <= total){// 执行着某种下载的任务usleep(50000);int rate = curr * 100 / total;cb(rate); // 通过回调，展示进度。curr += 10; // 每次下载10MB}printf("\n");
}

这样我们可以通过函数回调的方式来进行。
在主函数(main.c)中直接调用我们的DownLoad函数：

 DownLoad(ProcessBar4);

我们运行一下结果：

不仅如此，我们还可以实现多任务下载的一个情况：
我们在主函数写这样的语句

int main()
{// 版本5printf("DownLoda1:\n");DownLoad(ProcessBar4);printf("DownLoad2:\n");DownLoad(ProcessBar4);printf("DownLoad3:\n");DownLoad(ProcessBar4);printf("DownLoad4:\n");DownLoad(ProcessBar4);printf("DownLoad5:\n");DownLoad(ProcessBar4);return 0;
}

接下来我们运行一下：

我们会看到，当第二个任务的时候跟第一个不一样，欸？为什么呢？这是因为，我们刚在定义bar数组的时候，他是全局的，我们并没有刷新它的状态，所以可以理解为我们的数组是满的！！

我们有两种，一种是在我们的ProceBar函数中写一个mesert函数即可，另一种我们把他封装成函数，在主函数李直接掉用即可！

void InitBar()
{memset(processbar, '\0', sizeof(processbar));
}

我们在来看一下结果：

这样就不会出现上面的情况了，好了，介绍到这，我们的进度条5个版本就都介绍完了。

下面是完整代码的展示：

ProcessBar.h

#pragma once
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
typedef void (*callback_t)(int);
// 版本1
void ProcessBar1();
// 版本2
void ProcessBar2();
// 版本3
void ProcessBar3();
// 版本4
void ProcessBar4(int rate);
//
extern void InitBar();
 模拟一种安装或者下载
extern void DownLoad(callback_t cb);
// 倒计时
void Countdown();

ProcessBar.c

#include "ProcessBar.h"
#include <string.h>#define SIZE 101                 // 定义进度条的大小为 101（用于表示 100% 的进度和一个终止字符）
#define MAX_RATR 100             // 最大的进度比例，设置为 100
#define STYLE '*'                // 进度条的显示字符，这里选择的是 #
#define STIME 1000 * 200         // 每次更新进度条的时间延迟，设置为 200 毫秒（1000 微秒 × 200）
#define BODY '='                 // 进度条身体
#define TAIL '>'                 // 进度条尾巴
typedef void (*callback_t)(int); // 函数指针类型char processbar[SIZE];
// 定义一个字符串，包含四个字符，用于在进度条更新时显示不同的进度指示符
const char *str = "|/-\\";void ProcessBar1()
{// version1int rate = 0;                   // 初始化进度变量 rate 为 0。char Bar[SIZE];                 // 创建一个字符数组 Bar 用于表示进度条memset(Bar, '\0', sizeof(Bar)); // 将 Bar 数组的所有元素初始化为 '\0'，即清空数组。int num = strlen(str);          // 计算字符串 str 的长度（4），用于后续的指示符更新while (rate <= MAX_RATR)        // 当进度小于等于 100 时，继续循环。{// 打印格式化的字符串//%-100s: 打印进度条，宽度为 100，左对齐//%d%%: 打印当前进度百分比  %%: 是用来打印字面上的百分号字符 %//%c: 打印当前进度指示符//\r: 回车符，使下一次输出覆盖当前行printf("[%-100s][%d%%][%c]\r", Bar, rate, str[rate % num]);// 刷新输出缓冲区，确保进度条立即显示。fflush(stdout);// 暂停程序执行一段时间（200 毫秒），用于控制更新速度。usleep(STIME);// 将当前进度位置用 # 更新，rate++ 后自增Bar[rate++] = STYLE;}printf("\n");
}
void ProcessBar2()
{// version2int rate = 0;                   // 初始化进度变量 rate 为 0。char Bar[SIZE];                 // 创建一个字符数组 Bar 用于表示进度条memset(Bar, '\0', sizeof(Bar)); // 将 Bar 数组的所有元素初始化为 '\0'，即清空数组。int num = strlen(str);          // 计算字符串 str 的长度（4），用于后续的指示符更新while (rate <= MAX_RATR)        // 当进度小于等于 100 时，继续循环。{//\033[: 开始一个 ANSI 转义序列。\033 是 ASCII 字符 27（ESC），[ 后面跟随的数字定义了颜色和格式。//%d;%d: 这里有两个 %d，它们用于随机生成背景和前景的颜色。// 第一个 %d：rand() % 10 + 40，生成一个范围在 40 到 49 之间的整数，用于背景色（40-49 是标准的 ANSI 颜色代码）。// 第二个 %d：rand() % 10 + 30，生成一个范围在 30 到 39 之间的整数，用于前景色（30-39 是标准的 ANSI 颜色代码）。//%dm 是 printf 函数中用于格式化字符串的一个占位符，通常用于指定 ANSI 转义码中的颜色或样式。// 在这个中，d代表一个整数，m用于结束颜色或样式的设置。//\033[0m: 重置所有的属性和颜色，将后续的输出恢复到默认状态。这确保了前面的颜色设置只影响了进度条的显示，而不会影响之后的输出。//\033[40;%dm[%d%%]:(显示进度百分比)// rand() % 10 + 30：用于设置前景色，显示当前进度百分比。//[%d%%]：显示当前的进度百分比，rate 是当前进度值。//\033[40;%dm[%c]:(显示进度指示符)// rand() % 10 + 30：又一次设置前景色，用于显示当前的进度指示符。//[%c]：显示当前的进度指示符，使用 str[rate % num] 来从 str 字符串中选择一个字符。printf("\033[%d;%dm[%-100s]\033[0m\033[40;%dm[%d%%]\033[0m\033[40;%dm[%c]\033[0m\r",rand() % 10 + 40, rand() % 10 + 30, Bar, rand() % 10 + 30, rate, rand() % 10 + 30, str[rate % num]);// 刷新输出缓冲区，确保进度条立即显示。fflush(stdout);// 暂停程序执行一段时间（200 毫秒），用于控制更新速度。usleep(STIME);// 将当前进度位置用 # 更新，rate++ 后自增Bar[rate++] = STYLE;}printf("\n");
}void ProcessBar3()
{// version3int rate = 0;                   // 初始化进度变量 rate 为 0。char Bar[SIZE];                 // 创建一个字符数组 Bar 用于表示进度条memset(Bar, '\0', sizeof(Bar)); // 将 Bar 数组的所有元素初始化为 '\0'，即清空数组。int num = strlen(str);          // 计算字符串 str 的长度（4），用于后续的指示符更新while (rate <= MAX_RATR)        // 当进度小于等于 100 时，继续循环。{// 打印格式化的字符串//%-100s: 打印进度条，宽度为 100，左对齐//%d%%: 打印当前进度百分比  %%: 是用来打印字面上的百分号字符 %//%c: 打印当前进度指示符//\r: 回车符，使下一次输出覆盖当前行printf("[%-100s][%d%%][%c]\r", Bar, rate, str[rate % num]);// 刷新输出缓冲区，确保进度条立即显示。fflush(stdout);// 暂停程序执行一段时间（200 毫秒），用于控制更新速度。usleep(STIME);// 将当前进度位置用 # 更新，rate++ 后自增Bar[rate++] = BODY;// 此时我们的rate在下一个位置，我们让=的下一个位置弄为>// 小心越界问题if (rate <= 100)Bar[rate] = TAIL;}printf("\n");
}void ProcessBar4(int rate)
{// 版本4// 我们重点理解一下我们的进度条是如何被调用的// 判断越界if (rate < 0 || rate > 100)return;int num = strlen(str);printf("[%-100s][%d%%][%c]\r", processbar, rate, str[rate % num]);fflush(stdout);processbar[rate++] = BODY;if (rate < 100)processbar[rate] = TAIL;
}// 模拟一种安装或者下载
void DownLoad(callback_t cb)
{int total = 1000; // 假设我们有一个1000MB的东西int curr = 0;     // 当前下载了多少MB;while (curr <= total){// 执行着某种下载的任务usleep(50000);int rate = curr * 100 / total;cb(rate); // 通过回调，展示进度。curr += 10; // 每次下载10MB}printf("\n");
}void InitBar()
{memset(processbar, '\0', sizeof(processbar));
}// 倒计时
void Countdown()
{int Size = 10;while (Size){printf("%-2d\r", Size);fflush(stdout);sleep(1);Size--;}// printf("hello world");
}

main.c

#include "ProcessBar.h"
#include <unistd.h>int main()
{// 进度条// 版本一// ProcessBar1();// 版本二// ProcessBar2();// 版本3// ProcessBar3();// 版本4// 我们模拟一下实际的应用场景：/*int total = 1000; // 假设我们有一个1000MB的东西int curr = 0;     // 当前下载了多少MB;while (curr <= total){ProcessBar4(curr * 100 / total);// 执行着某种下载的任务curr += 10; // 每次下载10MBusleep(50000);}printf("\n");*/// 版本5printf("DownLoda1:\n");DownLoad(ProcessBar4);InitBar();printf("DownLoad2:\n");DownLoad(ProcessBar4);InitBar();printf("DownLoad3:\n");DownLoad(ProcessBar4);InitBar();printf("DownLoad4:\n");DownLoad(ProcessBar4);InitBar();printf("DownLoad5:\n");DownLoad(ProcessBar4);// 倒计时//  Countdown();return 0;
}

上述我们用到了函数回调，那么什么是函数回调呢？

函数回调

回调函数是指通过函数指针传递给另一个函数的函数。当这个函数执行到某个特定点时，它会调用传入的回调函数。这种机制在许多编程语言中广泛应用，尤其是在处理异步操作、事件驱动编程和高阶函数时。

回调函数的特点：

1. 灵活性：通过传递不同的回调函数，可以在同一个操作中实现不同的行为。
2. 异步编程：常用于异步操作中，比如在网络请求完成后执行特定的代码。
3. 代码解耦：可以将业务逻辑与具体实现分离，提高代码的可读性和可维护性。

工作原理

1. 函数指针：回调函数通常通过函数指针来传递。函数指针允许我们引用一个函数并在需要时调用它。
2. 调用时机：当一个函数执行到特定的时刻（比如完成某项工作、接收到事件等），它会调用传入的回调函数。

使用场景

1. 事件驱动编程：在图形用户界面（GUI）应用程序中，用户的点击、输入等操作会触发事件，程序可以通过回调函数来响应这些事件。
2. 异步操作：例如，在进行网络请求时，程序可以继续执行其他任务，而在请求完成时，通过回调函数来处理响应结果。
3. 排序算法：在许多编程语言中，排序函数允许用户传入自定义的比较函数作为回调，以决定元素的排序方式。

示例

在C语言中，可以通过函数指针来实现回调函数。以下是一个简单的示例：

#include <stdio.h>// 定义一个回调函数类型
typedef void (*Callback)(int);// 一个接受回调函数的函数
void executeCallback(Callback cb, int value) 
{cb(value);  // 调用传入的回调函数
}// 一个具体的回调函数实现
void myCallback(int x) 
{printf("Callback called with value: %d\n", x);
}int main() 
{// 调用executeCallback并传入myCallback作为回调executeCallback(myCallback, 42);return 0;
}

在这个例子中，myCallback 是一个回调函数，它被传递给 executeCallback，后者在适当的时候调用它。这样就实现了函数之间的灵活交互。
运行结果：