一个毫秒级计时的类

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