一个用于在控制台中实现进度显示的类

三点一洲

由于在控制台中只能以打印字符的形式来进行输出，很多时候我们在运行比较大的程序时无法知道完成进度，所以写了一个类来实现这一功能。

1. 
   
2. //DosProgressBar header file
   
3. //"DosProgressBar"用于在控制台中实现进度显示
   
4. //版本号： 1.0.1
   
5. //作者：三点一洲
   
6. 
   
7. #pragma once
   
8. #include <cstring>
   
9. #include <cstdio>
   
10. #include <string>
    
11. #include <iostream>
    
12. #include <windows.h>
    
13. #define __ARR_CAPACITY 100
    
14. #define _INIT_VALUE 0
    
15. #define _MAX_VALUE 1
    
16. #define _PERCENT_MULTI 100
    
17. #define _BLOCK_NUMBERS 32
    
18. #define _DEFAULT_FLUSH_FREQUENCY 65536
    
19. #define _FLUSH_FREQUENCY 3
    
20. #define _FILL_BLOCK "█"
    
21. #define _STANDEARD_OUT_SIZE (_BLOCK_NUMBERS * 2 + 2)
    
22. #define _UNUSED_BAR 0
    
23. #define _USING_BAR 1
    
24. #define _USED_BAR 2
    
25. 
    
26. //设置光标位置(x, y)
    
27. void gotoxy(short, short);
    
28. //设置光标位置(COORD)
    
29. void gotoxy(COORD);
    
30. //返回当前光标位置
    
31. COORD wherexy();
    
32. //获取光标的位置y
    
33. int wherey();
    
34. //获取光标的位置x
    
35. int wherex();
    
36. //计算合适的刷新频率
    
37. int calcFrequency(int);
    
38. 
    
39. class DosProgressBar
    
40. {
    
41.     typedef int bar_status;
    
42.     typedef double progress_value;
    
43. 
    
44. private:
    
45.     progress_value nowValue;
    
46.     bar_status status;
    
47.     COORD outPos;
    
48.     int flushCount;
    
49.     int flushFrequency;
    
50. 
    
51. public:
    
52.     //格式化进度
    
53.     inline std::string percentFormate()
    
54.     /* 格式化当前进度 */
    
55.     {
    
56.         char s[__ARR_CAPACITY];
    
57.         sprintf(s, "%.2f%%", nowValue * _PERCENT_MULTI);
    
58.         //std::cout<<std::string(s)+"\n";
    
59.         return std::string(s);
    
60.     }
    
61.     //设置当前进度
    
62.     inline progress_value setNowValue(progress_value pv)
    
63.     /* 设置进度值 */
    
64.     {
    
65.         nowValue = pv;
    
66.         return pv;
    
67.     }
    
68.     //获得当前进度
    
69.     inline progress_value getNowValue()
    
70.     /* 获得当前进度 */
    
71.     {
    
72.         return nowValue;
    
73.     }
    
74. 
    
75. private:
    
76.     //int printProgressBar(const char end = '\0');
    
77.     /* 按频率打印出进度条 */
    
78.     //int printProgressBar(const std::string &, const char end = '\0');
    
79.     /* 按频率打印出有后缀进度条 */
    
80. 
    
81.     //回退到开始光标
    
82.     void backToStartPos();
    
83.     //立即打印进度条
    
84.     int printProgressBarSoon(const char end = '\0');
    
85.     //立即打印有后缀进度条
    
86.     int printProgressBarSoon(const std::string &, const char end = '\0');
    
87. 
    
88. public:
    
89.     //刷新进度条
    
90.     void flushProgressBar(progress_value);
    
91.     //重置进度条
    
92.     void reSetBar();
    
93.     //设置合理刷新频率
    
94.     void setFrequency(int);
    
95. 
    
96. public:
    
97.     inline DosProgressBar(void) : nowValue(0), flushCount(0), outPos({0, 0}), status(_UNUSED_BAR), flushFrequency(_DEFAULT_FLUSH_FREQUENCY)
    
98.     {
    
99.     }
    
100.     inline DosProgressBar(progress_value _nowValue) : nowValue(_nowValue), flushCount(0), outPos({0, 0}), status(_UNUSED_BAR), flushFrequency(_DEFAULT_FLUSH_FREQUENCY)
     
101.     {
     
102.     }
     
103.     ~DosProgressBar(void) {}
     
104. };
     

复制代码

1. 
   
2. //DosProgressBar source file
   
3. //"DosProgressBar"用于在控制台中实现进度显示
   
4. //版本号： 1.0.1
   
5. //作者：三点一洲
   
6. 
   
7. #include "DosProgressBar.h"
   
8. #include <cmath>
   
9. 
   
10. //获取光标的位置x
    
11. int wherex()
    
12. {
    
13.     CONSOLE_SCREEN_BUFFER_INFO pBuffer;
    
14.     GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &pBuffer);
    
15.     return pBuffer.dwCursorPosition.X;
    
16. }
    
17. 
    
18. //获取光标的位置y
    
19. int wherey()
    
20. {
    
21.     CONSOLE_SCREEN_BUFFER_INFO pBuffer;
    
22.     GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &pBuffer);
    
23.     return pBuffer.dwCursorPosition.Y;
    
24. }
    
25. 
    
26. //返回当前光标位置
    
27. COORD wherexy()
    
28. {
    
29.     COORD _coord;
    
30.     CONSOLE_SCREEN_BUFFER_INFO pBuffer;
    
31.     GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &pBuffer);
    
32.     _coord.X = pBuffer.dwCursorPosition.X;
    
33.     _coord.Y = pBuffer.dwCursorPosition.Y;
    
34.     return _coord;
    
35. }
    
36. 
    
37. //设置光标位置(x, y)
    
38. void gotoxy(short x, short y)
    
39. {
    
40.     COORD pos = {x, y};
    
41.     HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    
42.     SetConsoleCursorPosition(hOut, pos);        
    
43. }
    
44. 
    
45. //设置光标位置(COORD)
    
46. void gotoxy(COORD _coord)
    
47. {
    
48.     COORD pos = _coord;
    
49.     HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    
50.     SetConsoleCursorPosition(hOut, pos);      
    
51. }
    
52. 
    
53. //计算合适的刷新频率
    
54. int calcFrequency(int _t)
    
55. {
    
56.     int t = (int)(_t / _BLOCK_NUMBERS / ((int)(log( _t < exp(2) ? exp(2) : _t ) / 2)) + 1);
    
57.     return t;
    
58. }
    
59. 
    
60. //回退到开始光标
    
61. void DosProgressBar::backToStartPos()
    
62. {
    
63.     gotoxy(outPos);
    
64.     return;
    
65. }
    
66. 
    
67. //立即打印进度条
    
68. int DosProgressBar::printProgressBarSoon(const char end)
    
69. {
    
70.     std::string outs("|");
    
71.     int block = (int)(nowValue * _BLOCK_NUMBERS);
    
72.     for (int i = 0; i < block; i++)
    
73.     {
    
74.         outs += _FILL_BLOCK;
    
75.     }
    
76.     outs += std::string(_STANDEARD_OUT_SIZE - 2 - block * 2, ' ');
    
77.     outs += "|";
    
78.     outs += "  " + percentFormate();
    
79.     if (end != '\0')
    
80.         outs += end;
    
81.     return printf("%s", outs.c_str());
    
82. }
    
83. 
    
84. //立即打印有后缀进度条
    
85. int DosProgressBar::printProgressBarSoon(const std::string &suffix, const char end)
    
86. {
    
87.     int n = printProgressBarSoon('\0') + printf("%s", suffix.c_str());
    
88.     if (end != '\0')
    
89.         return n + printf("%c", end);
    
90.     else
    
91.         return n;
    
92. }
    
93. 
    
94. //刷新进度条
    
95. void DosProgressBar::flushProgressBar(progress_value pv)
    
96. {
    
97.     if (status == _UNUSED_BAR)
    
98.     {
    
99.         //std::cout<<"\n"<<flushFrequency<<std::endl;
    
100.         status = _USING_BAR;
     
101.         COORD _co = wherexy();
     
102.         if (_co.X > 0)
     
103.         {
     
104.             _co.Y++;
     
105.             _co.X = 0;
     
106.         }
     
107.         outPos = _co;
     
108.         gotoxy(outPos);
     
109.     }
     
110.     else if (status == _USED_BAR)
     
111.     {
     
112.         std::cerr << "进度条已使用，请重置后继续使用" << std::endl;
     
113.         //exception 1
     
114.         //exit(0);
     
115.     }
     
116.     setNowValue(pv);
     
117.     ++flushCount;
     
118.     int resetFlag = flushCount / flushFrequency;
     
119.     flushCount %= flushFrequency;
     
120.     if (resetFlag || nowValue == 1.0)
     
121.     {
     
122.         gotoxy(outPos);
     
123.         printProgressBarSoon('\n');
     
124.         if (!(nowValue == 1.0))
     
125.         {
     
126.             gotoxy(outPos);
     
127.         }
     
128.         else
     
129.         {
     
130.             status = _USED_BAR;
     
131.         }
     
132.     }
     
133. }
     
134. 
     
135. //重置进度条
     
136. void DosProgressBar::reSetBar()
     
137. {
     
138. }
     
139. 
     
140. //设置合理刷新频率
     
141. void DosProgressBar::setFrequency(int total)
     
142. {
     
143.     flushFrequency = calcFrequency(total);
     
144.     return;
     
145. }
     

复制代码

1. 
   
2. #include "DosProgressBar.h"
   
3. #define N 100000000  //总循环次数
   
4. int main()
   
5. {
   
6.     DosProgressBar dpb(0.0);
   
7.     dpb.setFrequency(N);
   
8.     for (int i = 0; i <= N ; i++)
   
9.     {
   
10.         dpb.flushProgressBar(i * 1.0 / N);
    
11.     }
    
12.     return 0;
    
13. }

复制代码