boost：timer库学习

素颜马尾好姑娘i 2022-12-15 03:40 265阅读 0赞

>  *  C++一直缺乏对时间和日期的处理能力，而boost使用`timer`、`date_time`和`chrono`提供了解决方案。
>  *  在这三个库中，`chrono`与平台相关，而`timer`、`date_time`与平台无关。这里我们来学习`timer`库

*  timer是一个很小的库，提供简易的度量时间和进度显示的功能，可以用于性能测试等需要计时的任务，适用于大多数情况
 *  boost1.48以后的timer库由两个组件组成：
    
     *  早期的timer(v1)：使用的是标准的C/C++库函数，计时精度低
     *  新的cpu\_timer(v2)：基于chrone库使用操作系统API，计时精度高
 *  我们先来学习timer(v1)组件。timer(v1)库包含两个小组件
    
     *  timer
     *  progress\_timer
     *  progress\_display

# timer #

*  测量时间的流逝，是一个小型的计时器。

## 头文件 ##

> \#include <boost/timer.hpp>  
> using namespace boost;

## 用法 ##

#include <iostream>
    using namespace std;
    
    // disable pragma warning
    #define BOOST_ALLOW_DEPRECATED_HEADERS
    
    #include <boost/timer.hpp>
    using namespace boost;
    
    int main() {
        
        timer t; // 定义timer对象，并开始计时
    
        cout << CLOCKS_PER_SEC << endl; //CLOCKS_PER_SEC是标准c的time.h头函数中宏定义的一个常数，表示一秒钟内CPU运行的时钟周期数，用于将clock()函数的结果转化为以秒为单位的量，但是这个量的具体值是与操作系统相关的。
    
        cout << "可以度量的最大时间:"
             << t.elapsed_max() /3600 << "h" <<endl;
        cout << "可以度量的最小时间:"
             << t.elapsed_min() << "s" << endl;
        cout << "now time elapsed:"
             << t.elapsed() <<"s" << endl;
    
    
        return 0;
    }

![在这里插入图片描述][20201015112508708.png_pic_center]

## 源码学习 ##

#ifndef BOOST_TIMER_HPP
    #define BOOST_TIMER_HPP
    
    #include <boost/config.hpp>
    #include <ctime>
    #include <boost/limits.hpp>
    
    # ifdef BOOST_NO_STDC_NAMESPACE
        namespace std {
         using ::clock_t; using ::clock; }
    # endif
    
    
    namespace boost {
        
    class timer
    {
        
     public:
             /*
    		 * 构造函数中记录当前clock数转为计时起点
    		 *      std::clock();是标准库头文件中#include <ctime>的，返回从进程启动以来的clock数
    		 *      每秒的clock数由宏CLOCKS_PER_SEC定义
    		 */
             timer() {
        _start_time = std::clock(); } 
    		 /*为什么没有析构函数：因为没有资源可以释放*/
      void   restart() {
         _start_time = std::clock(); } // 重置计时起点
      double elapsed() const                 
        {
         
    	      return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; 
    	}    //过去的时间(s) =  当前clock - 计时起点clock / CLOCKS_PER_SEC   
    
      double elapsed_max() const   // 能够测量的最大时间(s) = (获取std::clock_t能够表达的最大值 - 计时起点) /CLOCKS_PER_SEC
      {
        
        return (double((std::numeric_limits<std::clock_t>::max)()) - double(_start_time)) / double(CLOCKS_PER_SEC); 
      }
    
      double elapsed_min() const   // 能够测量的最小时间(s)
       {
         return double(1)/double(CLOCKS_PER_SEC); }
    
     private:
      std::clock_t _start_time;
    };
    
    } 
    
    #endif

注意：  
CLOCKS\_PER\_SEC 因为操作系统的不同而不同。

*  macOS，Linux是 1 000 000 ----》 精度是微秒
 *  windows 是 1 000 ----》 精度是毫秒

## 使用建议 ##

*  适用于要求不高的计时任务
 *  不适用高精度的时间测量，因为它的精度依赖操作系统，不能跨平台
 *  不适用与大跨度时间测量，如果测量时间大于天，用`cpu_timer`组件

# progress\_timer #

## 头文件 ##

> \#include <boost/progress.hpp>  
> using namespace boost;

## 用法 ##

*  `progress_timer` 继承自timer，是一个定时器， 可以向timer那样使用。 当然，他有自己的扩展功能：不需要任何调用，定义就可以直接使用，当退出作用域的时候，会调用析构函数，自动输出距定义progress\_timer的时间

#include <boost/progress.hpp>
    using namespace boost;
    
    int main() {
        
        progress_timer t;
        return 0;
    }

![在这里插入图片描述][20201015125413154.png_pic_center]

*  如果要测量多个时间，可以用\{\}限定`progress_timer`生命周期。

#include <boost/progress.hpp>
    using namespace boost;
    
    int main() {
        
        {
        
            progress_timer t;
        }
    
        {
        
            progress_timer t;
        }
        return 0;
    }

![在这里插入图片描述][20201015125613673.png_pic_center]

*  `progress_timer`的构造函数中有一个参数std::ostream & os = std::cout，表示默认输出到std::cout；当然，我们可以将析构时的输出定向到其他IO流里面。

#include <boost/progress.hpp>
    #include <sstream>
    
    using namespace boost;
    
    int main() {
        
        std::stringstream ss;
        {
        
            progress_timer t(ss);
        }
        std::cout << ss.str();
        return 0;
    }

![在这里插入图片描述][20201015125744815.png_pic_center]

## 源码学习 ##

class progress_timer : public timer, private noncopyable
    {
        
      
     public:
      explicit progress_timer( std::ostream & os = std::cout )
         : m_os(os) {
        }
      ~progress_timer()
      {
        
        try
        {
        
    		//std::istream::fixed,std::istream::floatfield 表示采用顶点计数法   https://blog.csdn.net/xionghui96/article/details/108307472
          std::istream::fmtflags old_flags = m_os.setf( std::istream::fixed,
                                                       std::istream::floatfield );
          std::streamsize old_prec = m_os.precision( 2 );  //指定尾数
          m_os << elapsed() << " s\n" //  elapsed() 表示调用timer的 elapsed()函数
                            << std::endl;
          m_os.flags( old_flags );
          m_os.precision( old_prec );
        }
    
        catch (...) {
        } // eat any exceptions
      } // ~progress_timer
    
     private:
      std::ostream & m_os;
    };

## 使用建议 ##

progress\_timer的目的就是为了简化timer的调用，其他没什么。

# progress\_display 【没用过】 #

*  `progress_display`是一个独立的组件，**可以在控制台上显示程序的执行进度**

## 头文件 ##

> \#include <boost/progress.hpp>  
> using namespace boost;

## 用法 ##

#include <boost/progress.hpp>
    using namespace boost;
    using namespace std;
    #include <fstream>
    #include "vector"
    //
    
    void case1()
    {
        
        vector<string> v(100);
        ofstream fs("./test.txt");
    
        //progress_display pd(v.size(),cout ,"%%%", "+++", "???");
        progress_display pd(v.size());
    
        for (auto& x : v)
        {
        
            fs << x << endl;
            ++pd;
        }
    }
    
    //
    
    void case2()
    {
        
        vector<string> v(100, "aaa");
    
        v[10] = "";v[23] = "";
        ofstream fs("./test.txt");
        progress_display pd(v.size());
    
        for (auto pos = v.begin(); pos != v.end();++pos)
        {
        
            fs << *pos << endl;
            ++pd;
            if (pos->empty())
            {
        
                cout << "null string # "
                     << (pos - v.begin())<< endl;
            }
        }
    }
    
    //
    
    int main()
    {
        
        case1();
        case2();
    }

[20201015112508708.png_pic_center]: /images/20221123/913a721fd4e7499d8f7d1d6f88b4fd38.png
[20201015125413154.png_pic_center]: /images/20221123/1484a4fb4de241f1b9b71d36270f4941.png
[20201015125613673.png_pic_center]: /images/20221123/818b79b6b14945948fbcccff76791671.png
[20201015125744815.png_pic_center]: /images/20221123/eaaba6bb4e91410b82aacb6b1bf1b316.png