当前位置： 首页 > article >正文

手把手写Linux第一个小程序 - 进度条（5种版本）

article 2024/11/2 23:53:23

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

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

目录

  • Linux第一个小程序 - 进度条
    • 行缓冲区的概念
    • \r和\n
    • 进度条代码及效果展示
    • 版本一：
      • Makefile：
      • process.h
      • process.c
      • main.c
    • 版本二：
      • Makefile：
      • process.h
      • process.c
      • main.c
    • 版本3
      • makefile
      • ProcessBar.c
      • ProcessBar.h
      • main.c
    • 版本4
      • ProcessBar.h
      • ProcessBar.c
      • main.c
    • 版本5（封神）
      • ProcessBar.h
      • ProcessBar.c
      • main.c
  • 函数回调
    • 回调函数的特点：
    • 工作原理
    • 使用场景
    • 示例

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.c
	gcc -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()
{
    //version1
    int 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.c
	gcc -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()
{
    //version1
    int 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.c
	gcc -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()
{
    // version1
    int 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()
{
    // version2
    int 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()
{
    // version3
    int 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();

    // 版本3
    ProcessBar3();
    
    // 倒计时
    //  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()
{
    // version1
    int 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()
{
    // version2
    int 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()
{
    // version3
    int 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; // 每次下载10MB
        usleep(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()
{
	// 版本5
    printf("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()
{
    // version1
    int 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()
{
    // version2
    int 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()
{
    // version3
    int 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; // 每次下载10MB
        usleep(50000);
    }
    printf("\n");*/

    // 版本5
    printf("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，后者在适当的时候调用它。这样就实现了函数之间的灵活交互。
运行结果：
在这里插入图片描述


http://www.kler.cn/a/376498.html

相关文章：

  • 构建灵活、高效的HTTP/1.1应用：探索h11库
  • LeetCode100之找到字符串中所有字母异位词(438)--Java
  • 基于知识引导提示的因果概念提取（论文复现）
  • 慢即是快，少即是多
  • 显示浏览器窗口的大小
  • C#制作学生管理系统
  • OpenSSH用户枚举漏洞修复——ubuntu升级ssh版本
  • 线程函数和线程启动的几种不同形式
  • 掌握ElasticSearch（七）：相关性评分
  • Axios-Mock-Adapter mock数据
  • 《卷积、卷积操作、卷积神经网络原理探索》
  • 3. 探索 Netty 的粘包与拆包解决方案
  • ARM base instruction -- mneg
  • 正点原子阿尔法ARM开发板-IMX6ULL（十一）——IIC协议和SPI协议--AP3216C环境光传感器和ICM20608六轴传感器
  • 在Zetero中调用腾讯云API的输入密钥的问题
  • 【Linux】信号三部曲——产生、保存、处理
  • ES跟Kafka集成
  • git 切换分支
  • 一个运维牛人对运维规则的10个总结
  • 秒懂Linux之Socket编程（四）
  • 支持向量机SVM与自然语言处理基础小结
  • 2024.10.2校招 实习 内推 面经
  • 函数基础，定义与调用。作用域，闭包函数
  • 升序数组两两不相等
  • C语言稀有关键词：柔性数组
  • 【创建型】单例模式