一个毫秒级计时的类

1 #ifndef _GHH_TIMER_GHH_
 2 #define _GHH_TIMER_GHH_    1
 3 
 4 // File: ghhTimer.h
 5 // Date: 2006.08.14
 7 
 8 #include <ctime>
 9 
10 // 类导出导入类别的符号定义
11 #ifdef _DLL_FILE_
12 #define PORTTYE __declspec(dllexport) // 导出
13 #else
14 #define PORTTYE __declspec(dllimport) // 导入
15 #endif    // end of _DLL_FILE_
16 
17 /**//****************************************************************************
18  * 类名称    ghhTimer
19  * 
20  * 描述
21  *    本类对标准库计时函数进行了封装，可以实现非常精确的计时，毫秒级别
22  *
23  * 使用说明
24  *    在所要计时程序段之前，调用Start函数，程序段结束时，调用Pause函数，
25  *    多次调用程序段，即可以比较精确的估计程序段的运行时间
26 ****************************************************************************/
27 class  PORTTYE ghhTimer
28 {
29 public:
30     ghhTimer();
31 
32 public:
33     bool Start(void); 
34     bool Stop(void);    
35     bool Pause(void);
36     size_t GetSeconds(void) const;
37     size_t GetMiliSeconds(void) const;
38 
39 private:
40     enum {run = 1, stop, pause} _Status;
41     time_t _Clock;
42     time_t _TotalClocks;
43 };
44 
45 #endif // end of _GHH_TIMER_GHH_

 1 #ifndef _DLL_FILE_
  2 #define _DLL_FILE_
  3 #endif
  4 #include "ghhTimer.h"
  5 
  6 /**//****************************************************************************
  7  * about the important function "clock()"
  8  * #include <time.h>
  9  * clock_t clock( void );
 10  * The clock() function returns the processor time since the program started, 
 11  * or -1 if that information is unavailable. 
 12  * To convert the return value to seconds, divide it by CLOCKS_PER_SEC. 
 13  * (Note: if your compiler is POSIX compliant, 
 14  * then CLOCKS_PER_SEC is always defined as 1000000.)
 15  ***************************************************************************/
 16 
 17 
 18 // 构造函数，设置初始状态
 19 ghhTimer::ghhTimer() : _Status(stop), _Clock(0), _TotalClocks(0)
 20 {
 21 }
 22 
 23 // 当表已经停止或者暂停时启动停表，成功返回true,否则返回false
 24 bool ghhTimer::Start(void)
 25 {
 26     switch (_Status)
 27     {
 28     case stop :
 29         _TotalClocks = 0;
 30         _Clock = clock();
 31         break;
 32 
 33     case pause :
 34         _Clock = clock();
 35         break;
 36 
 37     case run :
 38         break;
 39 
 40     default :
 41         return false;
 42     }
 43 
 44     _Status = run;
 45 
 46     return true;
 47 }
 48 
 49 // 表运行时暂停计时,成功返回true，否则返回false
 50 bool ghhTimer::Pause(void)
 51 {
 52     switch (_Status)
 53     {
 54     case stop :
 55     case pause :
 56         break;
 57 
 58     case run :
 59         _TotalClocks += (clock() - _Clock);
 60         _Clock = 0;
 61         _Status = pause;
 62         break;
 63 
 64     default :
 65         return false;
 66     }
 67 
 68     return true;
 69 }
 70 
 71 // 表运行或暂停时停止计时
 72 bool ghhTimer::Stop(void)
 73 {
 74     switch (_Status)
 75     {
 76     case stop :
 77     case pause :
 78         break;
 79         
 80     case run :
 81         _TotalClocks +=(clock() - _Clock);
 82         _Clock = 0;
 83         break;
 84 
 85     default :
 86         return false;
 87     }
 88 
 89     _Status = stop;
 90     
 91     return true;
 92 }
 93 
 94 // 得到当前积累的秒数
 95 size_t ghhTimer::GetSeconds(void) const
 96 {
 97     time_t Clocks;
 98 
 99     switch (_Status)
100     {
101     case stop:
102     case pause:
103         Clocks = _TotalClocks;
104         break;
105 
106     case run:
107         Clocks = _TotalClocks + clock() - _Clock;
108         break;
109 
110     default:
111         return false;
112     }
113     return (Clocks / CLOCKS_PER_SEC);
114 }
115 
116 // 得到当前积累的毫秒数
117 size_t ghhTimer::GetMiliSeconds(void) const
118 {
119     time_t Clocks;
120 
121     switch(_Status)
122     {
123     case stop:
124     case pause:
125         Clocks = _TotalClocks;
126         break;
127     case run:
128         Clocks = _TotalClocks + clock() - _Clock;
129         break;
130 
131     default:
132         return false;
133     }
134     return (Clocks * 1000 / CLOCKS_PER_SEC);
135 }
136