Annuaire d'articles
1. Comprendre le retour chariot et le saut de ligne
Dans le langage C que nous connaissons, un retour à la ligne peut sauter au début de la ligne suivante, mais en fait cette opération comporte deux étapes, \r (retour chariot) et \n (retour à la ligne)
\rEnter est de revenir au début de cette ligne
\nNewline est de commencer une nouvelle ligne
2. Comprendre la mise en mémoire tampon de ligne
Un espace est réservé en mémoire pour tamponner les données d'entrée ou de sortie, et cet espace réservé est appelé tampon. Comprenons le concept de mise en mémoire tampon de ligne à travers quelques exemples de code
1. Code 1 et 2 (comprendre retour chariot et saut de ligne)
Coder un :
1#include <stdio.h>
2 int main()
3 {
4 printf("hello world\n");
5 return 0;
6 }
Code deux :
1#include <stdio.h>
2 int main()
3 {
4 printf("hello world\r");
5 return 0;
6 }
Il n'est pas difficile de trouver que \n peut être imprimé, mais que \r ne peut pas être imprimé, car le mode d'affichage est que le tampon d'actualisation de ligne est mis en mémoire tampon par ligne, sans \n, il ne peut pas être actualisé immédiatement.\r Après retour au début de la ligne, elle sera écrasée, l'invite du shell écrasera le "hello world" précédemment écrit. Si nous n'ajoutons pas \r à "hello world", il ne sera pas écrasé et l'invite du shell écrira "hello world" à l'envers
comme suit:
2. Code trois et quatre (compréhension de la fonction sommeil et de la fonction ffush)
La mise en mémoire tampon de ligne est une sorte de stratégie de vidage de mémoire tampon. En mode de mise en mémoire tampon de ligne, lorsqu'une nouvelle ligne '\n' est rencontrée dans l'entrée et la sortie, la mémoire tampon sera actualisée. Ci-dessous, nous connaissons la fonction <unistd.h> des trois fichiers d'en-tête
dormir dormirs l ee p : fonction sleep sous Linux, l'unité est usleep
usleepu s l ee p : Identique au sommeil, unité ms (soit 10-6m)
fflush fflushff l u s h : vider le tampon
Code 3 :
1 #include <stdio.h>
2 #include <unistd.h>
3 int main()
4 {
5 printf("hello world");
6 sleep(3);
7 return 0;
8 }
Nous savons que les instructions de code de fonction sont exécutées séquentiellement de haut en bas, mais ce que nous voyons, c'est qu'il dort pendant trois secondes, puis affiche "hello world",La raison en est que les données sont stockées dans la mémoire tampon et ne sont pas activement actualisées. Lorsque le programme se termine, les données stockées dans le tampon sont automatiquement rafraîchies. Si nous voulons rafraîchir à l'avance, nous pouvons appeler fflush fflushff l u s h fonction pour vider le tampon
Code quatre :
1 #include <stdio.h>
2 #include <unistd.h>
3 int main()
4 {
5 printf("hello world");
6 fflush(stdout);
7 printf("\n");
8 sleep(3);
9 return 0;
10}
Cette fois "hello world" est imprimé directement, nous ajoutons \n pour éviter le shell shellL' invite du shell apparaît après "hello world"
3. Compte à rebours simple
1. Affichage des effets
Avec le travail préparatoire ci-dessus, nous pouvons comprendre le principe de fonctionnement du compte à rebours et de la barre de progression. Ensuite, nous donnerons d'abord le code et l'effet, puis nous parlerons des détails.
2. Code de compte à rebours
1 #include <stdio.h>
2 #include <unistd.h>
3 int main()
4 {
5 int cnt=10;
6 while(cnt>=0)
7 {
8 printf("%-2d\r",cnt);
9 fflush(stdout);
10 sleep(1);
11 cnt--;
12 }
13 printf("\n");
14 return 0;
15 }
3. Réaliser l'analyse des processus
1. Définissez la variable de compte à rebours cnt , laissez-la diminuer progressivement
2. Le noyau consiste à utiliser \r pour revenir au début de la ligne de tampon à écraser, puis fflush l'actualise en continu
3. Ajustement du format, lors de l'impression cnt= =10 , imprimer dans le tampon En fait, il s'agit du caractère 1 et du caractère 0. Si nous n'utilisons pas 2d% pour ajuster le format, mais utilisons d% , alors l'écrasement ne couvrira que le premier caractère 1 11 position, tandis que le deuxième caractère0 00 , il reste dans la position d'origine du tampon, donc le compte à rebours deviendra comme suit
10->90->80->70->60->50->40->30->20->10->00,-2d%ajoutez un signe moins pour vous assurer qu'il est aligné sur la gauche
4, ajoutez un\naprès le compte à rebours,l'invite du shelln'apparaîtra pas après le compte à rebours
4. Barre de progression
1. Affichage des effets
2. Code à barres de progression
makefile
1 processbar:processBar.c main.c
2 gcc -o $@ $^
3 .PHONY:clean
4 clean:
5 rm -f processbar
Fichier d'en-tête processBar.h
1 #pragma once
2 #include<stdio.h>
3
4 #define SIZE 102
5 #define BODY '='
6 #define TAIL '>'
7
8 extern void processbar(int rate);
9 extern void initbar();
.c fichier processBar.c
1 #include "processBar.h"
2 #include <string.h>
3 #include <unistd.h>
4
5 #define LIGHT_GREEN "\033[1;32m" //亮绿色
6 #define NONE "\033[m" //截断
7
8 const char *lable="|/-\\";
9 char bar[SIZE];
10
11 void processbar(int rate)
12 {
13 if(rate<0 || rate > 100)
14 return;
15 //没有\n，就没有立即刷新，因为显示器模式是行刷新
16 printf(LIGHT_GREEN"[%-100s]"NONE"[%d%%][%c]\r",bar,rate,lable[rate%4]);
17 fflush(stdout);
18 bar[rate++]=BODY;
19 if(rate<100)
20 bar[rate]=TAIL;
21 }
22
23 void initbar()
24 {
25 memset(bar,'\0',sizeof(bar));
26 }
fichier .c main.c
1 #include "processBar.h"
2 #include <unistd.h>
3
4 typedef void(*callback_t)(int);
5 void downLoad(callback_t cb)
6 {
7 initbar();
8 int total=1000; // 1000MB
9 int curr=0; //0MB
10 while(curr<=total)
11 {
12 // 进行某种下载任务
13 usleep(50000); //模拟下载花费时间
14 int rate=curr*100/total;//更新进度
15
16 cb(rate); //回调展示进度
17 //processbar(curr*100/total);
18
19 curr+=10; // 循环下载了一部分，更新进度
20 }
21 printf("\n");
22 }
23
24
25 int main()
26 {
27 printf("download 1:\n");
28 downLoad(processbar);
29 printf("download 2:\n");
30 downLoad(processbar);
31 printf("download 3:\n");
32 downLoad(processbar);
33 printf("download 4:\n");
34 downLoad(processbar);
35 return 0;
36 }
3. Réaliser l'analyse des processus
style de barre de progression
Style de barre de progression :
le style du corps principal est entouré de deux crochets et le milieu => avance. Par exemple : [======>] La
position des crochets sur le côté droit du corps principal reste inchangée. , et l'élément du milieu continue d'avancer, tel que : [ => ]
Nous définissons donc le corps du milieu = macro comme BODY et le côté queue > macro comme TAIL
Pourcentage de la barre de progression :
affiche la progression actuelle du chargement, affichée en [taux %], la vitesse change avec la progression de la barre de progression et l'impression % (caractère d'échappement) nécessite deux %%
Caractère de rotation de la barre de progression :
affichez le style de chargement, vous pouvez utiliser un caractère rotatif, tel que le style [], tourner dans le sens des aiguilles d'une montre en continu, suivi de "| / - \" , notez que \ est également un caractère d'échappement, donc deux \ \ sont nécessaires , Pour cela nous définissons un pointeur lable pointant vers la chaîne constante const char * lable=" | / - \ "
Couleur de la barre de progression : référence de couleur du langage C
Nous pouvons colorer la barre de progression selon nos propres préférences, ici nous trouvons la table de référence des couleurs
et définissons la macro vert clair comme #define LIGHT_GREEN La macro à la fin de "\033[1;32m "
est défini comme #define NONE "\033[m"
Méthode de mise en œuvre de la barre de progression
Réservez la taille de la barre de progression à 100 = , plus 1 > , plus l'emplacement d'enregistrement \0 , et créez un tableau de barres qui stocke 102 (la macro est définie comme SIZE) unités. La fonction processbar() imprime la barre de progression d'un certain rapport, après que \r revient au début de la ligne, fflush rafraîchit le tampon, et en même temps insère = à la fin du tableau bar , puis insère > , notez que lorsque le taux est de 100, la barre de progression est chargée , il n'est donc pas nécessaire d'insérer >
pour simuler l'exécution d'une certaine tâche de téléchargement, et passez la méthode d'implémentation processbar() fonction en tant que paramètre à downLoad() simulation download function Pour cela, nous définissons un pointeur de fonction de type processbar() et le renommons callback_t . Nous définissons la taille du package de téléchargement comme total totalt o t a l , la progression actuelle estactuelle actuellec u rr , donc le taux de progression estrate=curr*100/total. Utilisezla fonction usleeppour simuler le temps de téléchargement, puis revenez en boucle pourrappeler la fonction processbar()pour réaliser la barre de progression. Enfin, compte tenu du deuxième téléchargement,le tableau de barres est pleineffaceronsle tableau de barresà chaque fois on appellela fonction downLoad()
