Linux小程序 —— 进度条

前言：经过这么多天的学习，想必大家学到了许多Linux知识，本日我们来用Linux来实现我们的第一个小程序 — — 进度条

---

---

   本篇告急内容将会实现三个版本的进度条：
  

• 简单原理版本
  
• 实际工程实践版本
  
• 拓展版本
  

  

   在实现进度条之前，我们先了解一些之前没提到过的知识，以便我们明白
  

---

  

---

1. 缓冲区的概念

我们先来分析下面几段代码感受一下行缓冲区的存在：
在Linux当中以下代码的运行效果是什么样的？

1. #include <stdio.h>
2. #include <unistd.h>                                                                                                                                                                    
3.   
4. int main()
5. {
6.     printf("你能看见我嘛\n");
7.     sleep(2);
8.     return 0;
9. }

复制代码

  这段代码运行效果显而易见：printf函数直接打印内容，然后休眠2秒。
  对于大家大概没有什么难度。那如果我们修改一下代码。

1. #include <stdio.h>
2. #include <unistd.h>                                                                                                                                                                    
3.   
4. int main()
5. {
6.     printf("你能看见我嘛");
7.     sleep(2);
8.     return 0;
9. }

复制代码

     缓冲区的概念
  
通过视频我们发现，我仅仅是将\n删除了，但是却带来了完全不一样的运行效果：先休眠2秒，然后才是printf函数打印内容
   那么为什么会出现这种情况呢？ C语言实行代码的逻辑不应该是从上至下实行吗？
  

• 按照 C语言实行代码的逻辑printf确实已经运行了，只不过内容没有被表现出来！
  
• 内容地点的地区则是在输出缓冲区中！
  

  C/C++语言，会针对尺度输出，给我们提供默认的缓冲区
   fflush函数可以刷新缓冲区，如果我们想立马显现可以用函数刷新fflush()，而\n是一种刷新的计谋——行刷新，所以\n也能立马显现！
  

---

2. \r&&\n

   概念：
  

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

  光说大概大家不太明白，我们来实操看看：

1. #include <stdio.h>
2. #include <unistd.h>
4. int main()
5. {
6.         int cnt = 10;
7.         while(cnt)
8.         {
9.                 printf("%d\r", cnt--);
10.                 fflush(stdout);
11.                 sleep(1);
12.         }
13.         return 0;
14. }

复制代码

     回车 \r
  
我们可以看到在输出下一个数之前都让光标先回到本行首格。
但是为什么输出效果和我预想的完全不一样？

printf("%-2d\r", cnt--);
我们以两位字符进行输出，-则是表示靠左对齐，就可以正常输出了！

---

3. 进度条

在进行上面的铺垫之后，我们开始编写我们的第一个小程序。我们将用两个源文件和一个头文件，一个说明，一个调用，一个实现
   test.c：实现
test.h：说明
main.c：调用

1. // Makefile:
2. mytest:test.c main.c
3.      gcc -o $@ $^
4. .PHONY:clean
5. clean:
6.      rm -rf mytest

复制代码

---

3.1 版本一

在版本一中，我们只要简单实现一下基本的功能，得到一个基本框架就足够了。

1. // process_v1
3. //test.h：申明
4. pragma once
5. #include <stdio.h>
6. #include <string.h>
7. #include <unistd.h>
8.   
9. // 定义进度条的总长度，因为有'\0'的存在所以设为101
10. #define SIZE 101
11. // 定义进度条的当前进度
12. #define MAX_RATE 100
13. // 进度条的符号
14. #define STYLE '#'
15. // 进度条的休眠时间
16. #define STIME 1000*15
18. void process_v1();
20. .............
22. //test.c：实现
23. #include "test.h"
25. // 旋转光标
26. const char *str = "|/-\";
27. // \\：才能表示一个'\'
28. void process_v1()
29. {
30.      int rate = 0;
31.      //初始化进度条全为'\0'
32.      char bar[SIZE] = {0};
33.          //循环打印
34.          int num = strlen(str);
35.      while(rate <= MAX_RATE)
36.      {
37.      // 进度条的打印格式
38.      // -100：先取好[]的范围，然后靠左打印。
39.          printf("[%-100s][%d%%][%c]\r", bar, rate, str[rate%num]);      
40.      // 刷新缓冲区                                                                                                                                   
41.          fflush(stdout);
42.      // 休眠时长
43.          usleep(STIME);
44.      // 填充符号
45.          bar[rate++] = STYLE;
46.      }
47.      // 刷新
48.      printf("\n");
49. }
51. .............
53. //main.c：调用
54. #include "test.h>
56. int main()
57. {
58.         process();
59.         return 0;
60. }

复制代码

     进度条：版本一
  
我们的第一代进度条也就完成了，实现了基本的结构框架！而我们的进度条，肯定不能干自己的，一定是和某种使命关联起来的！

---

3.2 版本二

我们将循环改成内部维护一个简单的静态缓冲区，每次往缓冲区里面增加内容然后刷新缓冲区内容就可以
   不能一次将进度条打印完毕，否则不能与场景更好的联合

1. // process_v2
3. //test.h：申明
4. #pragma once
6. #include <stdio.h>
7. #include <string.h>
8. #include <unistd.h>
9.   
10. #define SIZE 101
11. #define MAX_RATE 100
12. #define STYLE '#'
13. #define STIME 1000*15
15. typedef void(*callback_t)(int); // 回调函数        
16. // 这里我们也可以使用函数指针                                                                                                                                                                                    
17. void process_v2(int);                                 
18. ~                           
19. .............
20. //main.c：调用
21. #include "test.h"
22.   
23. #define TARGET_SIZE 1024*1024 // 模拟下载软件的大小
24. #define DSIZE 1024*10 // 模拟下载的速度
25.   
26. //void download()
27. //{
28. //    int target = TARGET_SIZE; // 软件总体积
29. //    int total = 0; // 当前下载的大小
30. //
31. //    while(total < target)
32. //    {
33. //        usleep(STIME); // 用休眠时间，模拟下载时间
34. //        total += DSIZE;
35. //       process_v2(total*100/target);                                                                                                                                                  
36. //    }
37. //    printf("\n");
38. //}
39. // 回调函数
40. void download(callback_t cb)
41. {
42.     int target = TARGET_SIZE; // 软件总体积
43.     int total = 0; // 当前下载的大小
45.     while(total < target)
46.     {
47.         usleep(STIME); // 用休眠时间，模拟下载时间
48.         total += DSIZE;
49.         int rate = total*100/target;   
50.         cb(rate);                                                                                                                                               
51.     }
52.     printf("\n");
53. }
54.   
55. int main()
56. {
57.     download(process_v2);
58.     return 0;
59. }
60. .............
61. //test.c：实现
62. #include "test.h"
63.   
64. const char *str = "|/-\";
66. void process_v2(int rate)
67. {
68.     static char bar[SIZE] = {0};
69.     int num = strlen(str);
70.    
71.     if(rate <= MAX_RATE && rate >= 0)                                                                                                                                                  
72.     {
73.         printf("[%-100s][%d%%][%c]\r", bar, rate, str[rate%num]);
74.         fflush(stdout);
75.         bar[rate] = STYLE;
76.     }
77.     if(rate == MAX_RATE)
78.     {
79.         // 重新刷新为0
80.         memset(bar, '\0', sizeof(bar));
81.     }
82. }

复制代码

     进度条：版本二
  
我们也能完成进度条的实现，最后我们在优化一下，变成我们的版本三！。

---

3.3 版本三

因为版本二已经能将进度条完美的出现了，我们版本三，只是在二的底子上，美化一下，所以只是简单修改一点代码！

1. // test.h
2. #define STYLE_DEADER '>'
3. #define STYLE_BODY '='
5. typedef void (*callback_t)(double)；
7. .............
9. // main.c
10. // 我们在下载时，模拟下载中断的状态
11. void download(callback_t cb)
12. {
13.     int target = TARGET_SIZE; // 软件总体积
14.     int total = 0; // 当前下载的大小
16.     while(total <= target)
17.     {
18.         usleep(STIME); // 用休眠时间，模拟下载时间
19.         total += DSIZE;
20.         double rate = total*100/target;
21.         // 我们让下载进度永远维持在50%左右
22.         if(rate > 50.0)
23.         {
24.                 total = target/2;
25.         }  
26.         cb(rate);                                                                                                                                               
27.     }
28.     printf("\n");
29. }
31. .............
33. // test.c
34. if(rate <= MAX_RATE && rate >= 0)
35. {
36.     // 设置cnt是为了在下载终止时，光标依然能变化
37.     cnt++;
38.     cnt = cnt > num ? 0 : cnt;
39.     // \033[1;47;30m ... \033[0m 则是更改输出时字体和背景颜色
40.     printf("加载中...\033[1;47;30m%-100s\033[0m][%.1lf%%][%c]\r", bar, rate, str[cnt]);                                                      
41.     fflush(stdout);
42.     if(rate < MAX_RATE)
43.     {
44.         bar[(int)rate] = STYLE_BODY;
45.         bar[(int)rate+1] = STYLE_HEADER;
46.     }
47.     else{
48.            bar[(int)rate] = STYLE_BODY;
49.     }
50. }

复制代码

     进度条：版本三
  
我们可以发现，我们修改了字体颜色和配景，设置测试了大概碰到的中断情况，光标依旧会变革。当然了进度条另有许多情景，等候着各位开发！

---

4. 总结拓展

拓展：
关于print带颜格式化输出，我在这里推荐一篇博客，有兴趣的可以去了解一下
print带颜格式化输出

---

总结：
本篇我们简单了解了一下缓冲区，以及换行'\n'与回车'\r'的基本概念，然后由浅入深的先容了三个版本的进度条，当然了美化方式各位都不一样，都是可以的，我们的Linux第一个小程序就讲到这里
谢谢大家支持本篇到这里就竣事了

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。