精华内容
下载资源
问答
  • c++ windows下计时

    2014-07-23 14:01:00
    本文对Windows平台常用的计时函数进行总结,包括精度为秒、毫秒、微秒三种精度的 5种方法。分为在标准C/C++的二种time()及clock(),标准C/C++所以使用的time()及clock()不仅可以用在 Windows系统,也可以用于...

    多核时代不宜再用 x86 的 RDTSC 指令测试指令周期和时间

     

    陈硕
    Blog.csdn.net/Solstice

     

    自从 Intel Pentium 加入 RDTSC 指令以来,这条指令是 micro-benchmarking 的利器,可以以极小的代价获得高精度的 CPU 时钟周期数(Time Stamp Counter),不少介绍优化的文章[1]和书籍用它来比较两段代码的快慢。甚至有的代码用 RDTSC 指令来计时,以替换 gettimeofday() 之类的系统调用。在多核时代,RDTSC 指令的准确度大大削弱了,原因有三:

     

    1. 不能保证同一块主板上每个核的 TSC 是同步的;
    2. CPU 的时钟频率可能变化,例如笔记本电脑的节能功能;
    3. 乱序执行导致 RDTSC 测得的周期数不准,这个问题从 Pentium Pro 时代就存在。

     

    这些都影响了 RDTSC 的两大用途,micro-benchmarking 和计时。

     

    RDTSC 一般的用法是,先后执行两次,记下两个 64-bit 整数 start 和 end,那么 end-start 代表了这期间 CPU 的时钟周期数。

     

    在多核下,这两次执行可能会在两个 CPU 上发生,而这两个 CPU 的计数器的初值不一定相同(由于完成上电复位的准确时机不同),(有办法同步,见[3]),那么就导致 micro-benchmarking 的结果包含了这个误差,这个误差可正可负,取决于先执行的那块 CPU 的时钟计数器是超前还是落后。

     

    另外,对于计时这个用途,时间 = 周期数 / 频率,由于频率可能会变(比如我的笔记本的 CPU 通常半速运行在 800MHz,繁忙的时候全速运行在 1.6GHz),那么测得的时间也就不准确了。有的新 CPU 的 RDTSC 计数频率是恒定的,那么时钟是准了,那又会导致 micro-benchmarking 的结果不准,见 [2]。还有一个可能是掉电之后恢复(比如休眠),那么 TSC 会清零。 总之,用 RDTSC 来计时是不灵的。

     

    乱序执行这个问题比较简单 [1],但意义深远:在现代 CPU 的复杂架构下,测量几条或几十条指令的耗时是无意义的,因为观测本身会干扰 CPU 的执行(cache, 流水线, 多发射,乱序, 猜测),这听上去有点像量子力学系统了。要么我们以更宏观的指标来标示性能,把"花 xxx 个时钟周期"替换"每秒处理 yyy 条消息"或"消息处理的延时为 zzz 毫秒";要么用专门的 profiler 来减小对观测结果的影响(无论是 callgrind 这种虚拟 CPU,还是 OProfile 这种采样器)。

     

    虽然 RDTSC 废掉了,性能测试用的高精度计时还是有办法的 [2],在 Windows 用 QueryPerformanceCounter 和 QueryPerformanceFrequency,Linux 下用 POSIX 的 clock_gettime 函数,以 CLOCK_MONOTONIC 参数调用。或者按文献 [3] 的办法,先同步 TSC, 再使用它。(我不知道现在最新的 Linux 官方内核是不是内置了这个同步算法。也不清楚校准后的两个 CPU 的“钟”会不会再次失步。)

     

    通过调用SetThreadAffinityMask,就能为各个线程设置亲缘性屏蔽: 


      DWORD_PTR  SetThreadAffinityMask  ( 
          HANDLE  hThread,                                  //  handle  to  thread 
          DWORD_PTR  dwThreadAffinityMask    //  thread  affinity  mask 
      ); 
      该函数中的  hThread  参数用于指明要限制哪个线程,  dwThreadAffinityMask用于指明该线程 
      能够在哪个CPU上运行。dwThreadAffinityMask必须是进程的亲缘性屏蔽的相应子集。返回值 
      是线程的前一个亲缘性屏蔽。例如,可能有一个包含4个线程的进程,它们在拥有4个CPU的计算机上运行。如果这些线程中的一个线程正在执行非常重要的操作,而你想增加某个CPU始终可供它使用的可能性,为此你对其他3个线程进行了限制,使它们不能在CPU  0上运行,而只能在CPU  1、2和3上运行。因此,若要将3个线程限制到CPU  1、2和3上去运行,可以这样操作: 
       
      //线程0只能在cpu  0上运行 
      SetThreadAffinityMask(hThread0,0x00000001); 
      //线程1,2,3只能在cpu  1,2,3上运行 
      SetThreadAffinityMask(hThread1,0x0000000E); 
      SetThreadAffinityMask(hThread2,0x0000000E); 
      SetThreadAffinityMask(hThread3,0x0000000E); 
     
     
    本文对Windows平台下常用的计时函数进行总结,包括精度为秒、毫秒、微秒三种精度的 5种方法。分为在标准C/C++下的二种time()及clock(),标准C/C++所以使用的time()及clock()不仅可以用在 Windows系统,也可以用于Linux系统。在Windows系统下三种,使用Windows提供的API接口timeGetTime()、 GetTickCount()及QueryPerformanceCounter()来完成。文章最后给出了5种计时方法示例代码。

     

    标准C/C++的二个计时函数time()及clock()

     

    time_t time(time_t *timer);

    返回以格林尼治时间(GMT)为标准,从1970年1月1日00:00:00到现在的此时此刻所经过的秒数。

    time_t实际是个long长整型typedef long time_t;

    头文件:#include <time.h>

     

    clock_t clock(void);

    返回进程启动到调用函数时所经过的CPU时钟计时单元(clock tick)数,在MSDN中称之为挂钟时间(wal-clock),以毫秒为单位。

    clock_t实际是个long长整型typedef long clock_t;

    头文件:#include <time.h>

     

     

    Windows系统API函数

    timeGetTime()、GetTickCount()及QueryPerformanceCounter()

     

    DWORD timeGetTime(VOID);

    返回系统时间,以毫秒为单位。系统时间是从系统启动到调用函数时所经过的毫秒数。注意,这个值是32位的,会在0到2^32之间循环,约49.71天。

    头文件:#include <Mmsystem.h>            

    引用库:#pragma comment(lib, "Winmm.lib")  

     

    DWORD WINAPI GetTickCount(void);

    这个函数和timeGetTime()一样也是返回系统时间,以毫秒为单位。

    头文件:直接使用#include <windows.h>就可以了。

     

    高精度计时,以微秒为单位(1毫秒=1000微秒)。

    先看二个函数的定义

    BOOL QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount);

    得到高精度计时器的值(如果存在这样的计时器)。

    BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency);

    返回硬件支持的高精度计数器的频率(次每秒),返回0表示失败。

    再看看LARGE_INTEGER

    它其实是一个联合体,可以得到__int64 QuadPart;也可以分别得到低32位DWORD LowPart和高32位的值LONG HighPart。

    在使用时,先使用QueryPerformanceFrequency()得到计数器的频率,再计算二次调用QueryPerformanceCounter()所得的计时器值之差,用差去除以频率就得到精确的计时了。

    头文件:直接使用#include <windows.h>就可以了。

    转载于:https://www.cnblogs.com/dragon2012/p/3862865.html

    展开全文
  • Windows .net 各种计时方式 GetTickcount,multimedia timer 高性能定时器 etc. -Windows net under GetTickCount various timing, the Multimedia timer high-performance timer etc.
  • 关于windows下精确计时

    2015-05-07 20:15:05
    曾经使用QueryPerformanceFrequency和QueryPerformanceCounter进行精确计时,但是各种变频CPU,我觉得这种方法并不适用,虽然未曾实验过,但是从原理来看,加上在网上查的资料,确实是会出错了。 请问目前有什么...
  • 本文对Windows及Linux平台常用的计时函数进行总结,包括精度为秒、毫秒、微秒三种精度的各种函数。 比如Window平台特有的Windows API函数GetTickCount()、timeGetTime()、及QueryPerformanceCounter(), Linux...

    本文对Windows及Linux平台下常用的计时函数进行总结,包括精度为秒、毫秒、微秒三种精度的各种函数。
    比如Window平台下特有的Windows API函数GetTickCount()、timeGetTime()、及QueryPerformanceCounter(),
    Linux平台下特有的gettimeofday()函数,以及标准的C/C++函数time()和clock()。下面分别对此进行简单介绍并附上示例代码。

    通用的C/C++计时函数time()和clock()

    time_t time(time_t *timer);
    返回以格林尼治时间(GMT)为标准,从1970年1月1日00:00:00到现在的此时此刻所经过的秒数。
    time_t实际是个long长整型typedef long time_t;

    clock_t clock(void);
    返回进程启动到调用函数时所经过的CPU时钟计时单元(clock tick)数,在MSDN中称之为挂钟时间(wal-clock),以毫秒为单位。
    clock_t实际是个long长整型typedef long clock_t;

    Window平台特有函数
    DWORD timeGetTime(void);
    返回系统时间,以毫秒为单位。系统时间是从系统启动到调用函数时所经过的毫秒数。注意,这个值是32位的,会在0到2^32之间循环,约49.71天。

    DWORD WINAPI GetTickCount(void);
    这个函数和timeGetTime()一样也是返回系统时间,以毫秒为单位。

    高精度计时,以微秒为单位(1毫秒=1000微秒)。
    BOOL QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount);得到高精度计时器的值(如果存在这样的计时器)。
    BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency);返回硬件支持的高精度计数器的频率(次每秒),返回0表示失败。
    其中LARGE_INTEGER其实是一个联合体,可以得到__int64 QuadPart;也可以分别得到低32位DWORD LowPart和高32位的值LONG HighPart。
    在使用时,先使用QueryPerformanceFrequency()得到计数器的频率,再计算二次调用QueryPerformanceCounter()所得的计时器值之差,
    用差去除以频率就得到精确的计时了

    Linux平台特有函数
    int gettimeofday(struct timeval *tv,struct timezone *tz);
    获得当前精确时间(1970年1月1日到现在的时间),精度为微秒。
    保存时间的结构体
    strut timeval {
    long tv_sec; //秒数
    long tv_usec; //微秒数
    };

    #include <iostream>
    
    #if defined(_WIN32) || defined(WIN32)        /**Windows*/
    #define WINDOWS_IMPL
    #include <windows.h>
    #include <time.h>            //time() 、 clock()
    #include <Mmsystem.h>       //timeGetTime()
    #pragma comment(lib, "Winmm.lib") //timeGetTime()
    #elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(BSD)    /**Linux*/
    #define LINUX_IMPL
    #include <sys/time.h>        //gettimeofday()
    #endif
    #include <stdio.h>
    
    /***********************************************************
    通用的:
    time_t time(time_t *tloc);     //返回从1970年1月1日0点以来的秒数,精度为秒
    clock_t clock(): 返回该程序从启动到函数调用占用CPU的时间,精度为毫秒,但一般最小精度是33ms
    
    Windows特有:
    GetTickCount(): 返回从操作系统启动到现在所经过的毫秒数,精度毫秒,但最小精度是18ms
                    返回值以32位的双字类型DWORD存储,因此可以存储的最大值是2^32 ms约为49.71天,
    timeGetTime():    返回以毫秒计的系统时间,该时间为从系统开启算起所经过的时间,精度为毫秒
    QueryPerformanceCounter(): 返回高精确度性能计数器的值,精度为微妙,但是确切的精确计时的最小单位是与系统有关的
    
    Linux特有:
    gettimeofday(struct timeval *tv,struct timezone *tz); 获得当前精确时间(1970年1月1日到现在的时间),精度为微秒
    ***********************************************************/
    
    void MySleep(int sec_time)
    {
        #if defined(WINDOWS_IMPL)
            Sleep(sec_time*1000);
        #elif defined(LINUX_IMPL)
            sleep(sec_time);
        #endif
    }
    
    void test_time()
    {
        //通用的
        //用time()来计时  秒
        time_t timeBegin, timeEnd;
        timeBegin = time(NULL);
        MySleep(1);
        timeEnd = time(NULL);
        printf("%d\n", timeEnd - timeBegin);
    
        /*
         * Structure used in select() call, taken from the BSD file sys/time.h.
         */
        //struct timeval {
        //        long    tv_sec;         /* seconds */
        //        long    tv_usec;        /* and microseconds */
        //};
        timeval  val;
    
        //用clock()来计时  毫秒
        clock_t  clockBegin, clockEnd;
        clockBegin = clock();
        MySleep(1);
        clockEnd = clock();
        printf("%d\n", clockEnd - clockBegin);
    
    #ifdef WINDOWS_IMPL
        //Windows
    
        //用GetTickCount()来计时  毫秒
        DWORD  dwGTCBegin, dwGTCEnd;
        dwGTCBegin = GetTickCount();
        Sleep(1000);
        dwGTCEnd = GetTickCount();
        printf("%d\n", dwGTCEnd - dwGTCBegin);
    
        //用timeGetTime()来计时  毫秒
        DWORD  dwBegin, dwEnd;
        dwBegin = timeGetTime();
        Sleep(1000);
        dwEnd = timeGetTime();
        printf("%d\n", dwEnd - dwBegin);
    
        //用QueryPerformanceCounter()来计时  微秒
        LARGE_INTEGER  large_interger;
        double dff;
        __int64  c1, c2;
        QueryPerformanceFrequency(&large_interger);
        dff = large_interger.QuadPart;
        QueryPerformanceCounter(&large_interger);
        c1 = large_interger.QuadPart;
        Sleep(1000);
        QueryPerformanceCounter(&large_interger);
        c2 = large_interger.QuadPart;
        printf("高精度计时器频率%lf\n", dff);
        printf("第一次计时器值%I64d 第二次计时器值%I64d 计时器差%I64d\n", c1, c2, c2 - c1);
        printf("计时%lf毫秒\n", (c2 - c1) * 1000 / dff);
    
    #elif  defined(LINUX_IMPL)
        //Linux
    
        struct timeval tpstart,tpend;
        double timeuse;
        gettimeofday(&tpstart,NULL);
        sleep(1);
        gettimeofday(&tpend,NULL);
        timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec;//注意,秒的读数和微秒的读数都应计算在内
        printf("used time:%fus\n",timeuse);
    #endif
    
    }
    
    int main()
    {
        test_time();
            getchar();
        return 0;
    }

    转载地址:http://www.cnblogs.com/lizhenghn/p/3587799.html

    展开全文
  • 主要介绍了python实现windows计时锁屏功能,代码简单易懂,非常不错,具有一定的参考借鉴价值,需要的朋友可以参考
  • Windows 各种计时函数总结

    万次阅读 多人点赞 2011-10-09 10:42:30
    本文对Windows平台常用的计时函数进行总结,包括精度为秒、毫秒、微秒三种精度的5种方法。分为在标准C/C++的二种time()及clock(),标准C/C++所以使用的time()及clock()不仅可以用在Windows系统,也可以用于Linux...
     本文对Windows平台下常用的计时函数进行总结,包括精度为秒、毫秒、微秒三种精度的5种方法。分为在标准C/C++下的二种time()及clock(),标准C/C++所以使用的time()及clock()不仅可以用在Windows系统,也可以用于Linux系统。在Windows系统下三种,使用Windows提供的API接口timeGetTime()、GetTickCount()及QueryPerformanceCounter()来完成。文章最后给出了5种计时方法示例代码。

     

    标准C/C++的二个计时函数time()及clock()

     

    time_t time(time_t *timer);

    返回以格林尼治时间(GMT)为标准,从1970年1月1日00:00:00到现在的此时此刻所经过的秒数。

    time_t实际是个long长整型typedef long time_t;

    头文件:#include <time.h>

     

    clock_t clock(void);

    返回进程启动到调用函数时所经过的CPU时钟计时单元(clock tick)数,在MSDN中称之为挂钟时间(wal-clock),以毫秒为单位。

    clock_t实际是个long长整型typedef long clock_t;

    头文件:#include <time.h>

     

     

    Windows系统API函数

    timeGetTime()、GetTickCount()及QueryPerformanceCounter()

     

    DWORD timeGetTime(VOID);

    返回系统时间,以毫秒为单位。系统时间是从系统启动到调用函数时所经过的毫秒数。注意,这个值是32位的,会在0到2^32之间循环,约49.71天。

    头文件:#include <Mmsystem.h>            

    引用库:#pragma comment(lib, "Winmm.lib")  

     

    DWORD WINAPI GetTickCount(void);

    这个函数和timeGetTime()一样也是返回系统时间,以毫秒为单位。

    头文件:直接使用#include <windows.h>就可以了。

     

    高精度计时,以微秒为单位(1毫秒=1000微秒)。

    先看二个函数的定义

    BOOL QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount);

    得到高精度计时器的值(如果存在这样的计时器)。

    BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency);

    返回硬件支持的高精度计数器的频率(次每秒),返回0表示失败。

    再看看LARGE_INTEGER

    它其实是一个联合体,可以得到__int64 QuadPart;也可以分别得到低32位DWORD LowPart和高32位的值LONG HighPart。

    在使用时,先使用QueryPerformanceFrequency()得到计数器的频率,再计算二次调用QueryPerformanceCounter()所得的计时器值之差,用差去除以频率就得到精确的计时了。

    头文件:直接使用#include <windows.h>就可以了。

     

     

    下面给出示例代码,可以在你电脑上测试下。

    //Windows系统下time(),clock(),timeGetTime(),GetTickCount(),QueryPerformanceCounter()来计时 by MoreWindows
    #include <stdio.h>
    #include <windows.h>
    #include <time.h> //time_t time()  clock_t clock()
    #include <Mmsystem.h>             //timeGetTime()
    #pragma comment(lib, "Winmm.lib")   //timeGetTime()
    
    int main()
    {
    	//用time()来计时  秒
    	time_t timeBegin, timeEnd;
    	timeBegin = time(NULL);
    	Sleep(1000);
    	timeEnd = time(NULL);
    	printf("%d\n", timeEnd - timeBegin);
    	
    	
    	//用clock()来计时  毫秒
    	clock_t  clockBegin, clockEnd;
    	clockBegin = clock();
    	Sleep(800);
    	clockEnd = clock();
    	printf("%d\n", clockEnd - clockBegin);
    	
    	
    	//用timeGetTime()来计时  毫秒
    	DWORD  dwBegin, dwEnd;
    	dwBegin = timeGetTime();
    	Sleep(800);
    	dwEnd = timeGetTime();
    	printf("%d\n", dwEnd - dwBegin);
    	
    	
    	//用GetTickCount()来计时  毫秒
    	DWORD  dwGTCBegin, dwGTCEnd;
    	dwGTCBegin = GetTickCount();
    	Sleep(800);
    	dwGTCEnd = GetTickCount();
    	printf("%d\n", dwGTCEnd - dwGTCBegin);
    	
    	
    	//用QueryPerformanceCounter()来计时  微秒
    	LARGE_INTEGER  large_interger;
    	double dff;
    	__int64  c1, c2;
    	QueryPerformanceFrequency(&large_interger);
    	dff = large_interger.QuadPart;
    	QueryPerformanceCounter(&large_interger);
    	c1 = large_interger.QuadPart;
    	Sleep(800);
    	QueryPerformanceCounter(&large_interger);
    	c2 = large_interger.QuadPart;
    	printf("本机高精度计时器频率%lf\n", dff);
    	printf("第一次计时器值%I64d 第二次计时器值%I64d 计时器差%I64d\n", c1, c2, c2 - c1);
    	printf("计时%lf毫秒\n", (c2 - c1) * 1000 / dff);
    	
    	printf("By MoreWindows\n");
    	return 0;
    }


    下面是本人电脑上的测试结果:

     

     

     

    转载请标明出处,原文地址:http://blog.csdn.net/morewindows/article/details/6854764

     

    展开全文
  • 一文中,我们看到了Qt在windows下计时器的使用: 对于间隔为零的情况,Qt并没有动用系统的计时器 对于间隔非零的情况 间隔小于20ms 且系统支持多媒体计时器,则使用多媒体计时器 否则,使用普通计时器 ...

    QTimer源码分析(以Windows下实现为例) 一文中,我们看到了Qt在windows下对计时器的使用:

    • 对于间隔为零的情况,Qt并没有动用系统的计时器
    • 对于间隔非零的情况
      • 间隔小于20ms 且系统支持多媒体计时器,则使用多媒体计时器
      • 否则,使用普通计时器

    Qt 的这种策略应该能很好地满足我们的需求了,但qtcn上一个网友还是比较期待自己直接调用系统的多媒体计时器。既然这样,自己还是尝试写写吧,写一个自己的Timer类

    代码

    • 代码还是比较简单的,头文件 mmtimer.h 如下:
    #ifndef MMTIMER_H
    #define MMTIMER_H
    #include <qt_windows.h>
    #include <QtCore/QObject>
    
    class MMTimer : public QObject
    {
        Q_OBJECT
    public:
        explicit MMTimer(int interval, QObject *parent = 0);
        ~MMTimer();
    
    signals:
        void timeout();
    
    public slots:
        void start();
        void stop();
    
    friend void WINAPI CALLBACK mmtimer_proc(uint, uint, DWORD_PTR, DWORD_PTR, DWORD_PTR);
    
    private:
        int m_interval;
        int m_id;
    };
    
    #endif // MMTIMER_H
    • 源码文件 mmtimer.cpp 如下:
    #include "mmtimer.h"
    #include <MMSystem.h>
    #ifdef __MINGW32__ //w32api bug
    #define TIME_KILL_SYNCHRONOUS 0x0100
    #endif
    void WINAPI CALLBACK mmtimer_proc(uint timerId, uint, DWORD_PTR user, DWORD_PTR, DWORD_PTR)
    {
        MMTimer *t = reinterpret_cast<MMTimer*>(user);
        emit t->timeout();
    }
    
    MMTimer::MMTimer(int interval, QObject *parent) :
        QObject(parent),m_interval(interval),m_id(0)
    {
    }
    
    MMTimer::~MMTimer()
    {
        stop();
    }
    
    void MMTimer::start()
    {
        m_id = timeSetEvent(m_interval, 1, mmtimer_proc, (DWORD_PTR)this,
                     TIME_CALLBACK_FUNCTION | TIME_PERIODIC | TIME_KILL_SYNCHRONOUS);
    
    }
    
    void MMTimer::stop()
    {
        if (m_id){
            timeKillEvent(m_id);
            m_id = 0;
        }
    }

    说明

    上面的代码应该不需要什么解释了:

    • timeSetEvent 和 timeKillEvent 可直接查阅 MSDN
    • 另外,MinGW的win32api包,对TIME_KILL_SYNCHRONOUS没有定义,代码中做了一点修正

    请确保正确链接所需要的库

    LIBS += -lwinmm

    注意:MSDN 对timeSetEvent的介绍中这么说的(对此不做评论)

    Note  This function is obsolete. New applications should use CreateTimerQueueTimer to create a timer-queue timer.

    展开全文
  • 2011-02-23 14:51:19其实也是WINDOWS下的通用办法啦,只不过我用PYTHON表达。用win32api.GetSystemTime()不是太精确,值15毫秒才变一下,最好用time.clock(),这个能到毫秒级,最精确的办法是用...
  • windows下的时间计时

    2017-06-23 14:10:37
    标准C/C++的二个计时函数time()及clock()   time_t time(time_t *timer); 返回以格林尼治时间(GMT)为标准,从1970年1月1日00:00:00到现在的此时此刻所经过的秒数。 time_t实际是个long长整型type
  • 使用imp形式是为了把 windows.h 从头文件中拿掉,对于需要支持多平台的代码有用。 代码中为什么不用 std::unique_ptrStopwatchImp> ? 因为 unique_ptr 需要在解析头文件时知道 StopwatchImp 的定义。前置申明...
  • windows下C++高精度计时

    2019-10-05 16:11:30
    写代码时,经常会计算某一段代码的运行时间,以下提供一个微秒级别的类供参考 class CTimeCost { public: CTimeCost(const string &str) : m_str(str) ... QueryPerformanceFrequency(&...
  • 本文对Windows平台常用的计时函数进行总结,包括精度为秒、毫秒、微秒三种精度的5种方法。分为在标准C/C++的二种time()及clock(),标准C/C++所以使用的time()及clock()不仅可以用在Windows系统,也可以用于Linux...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 748
精华内容 299
关键字:

windows下计时