精华内容
下载资源
问答
  • 时间函数介绍Linux c/c++中提供了很多操作时间的库函数,这里简要介绍。使用头文件 #include常用的时间函数包括以下:time原型:time_t time(time_t *t);返回从公元1970年1月1日的UTC时间从0时0分0秒算起到现在所...

    时间函数介绍

    Linux c/c++中提供了很多操作时间的库函数,这里简要介绍。

    使用头文件 #include

    常用的时间函数包括以下:

    time

    原型:time_t time(time_t *t);

    返回从公元1970年1月1日的UTC时间从0时0分0秒算起到现在所经过的秒数

    如果t 并非空指针的话,此函数也会将返回值存到t指针所指的内存

    成功则返回秒数,失败则返回((time_t)-1)值,错误原因存于errno中

    localtime

    原型:struct tm *localtime(const time_t * timep);

    将参数timep所指的time_t结构中的信息转换成真实世界所使用的时间日期表示方法,然后将结果由结构tm返回

    成功则返回0,失败返回-1,错误代码存于errno

    结构tm的定义如下,此函数返回的时间日期已经转换成当地时区 struct tm {

    int tm_sec;

    int tm_min;

    int tm_hour;

    int tm_mday;

    int tm_mon;

    int tm_year;

    int tm_wday;

    int tm_yday;

    int tm_isdst;

    };

    gettimeofday

    原型:int gettimeofday ( struct timeval * tv , struct timezone * tz )

    把目前的时间由tv所指的结构返回,当地时区的信息则放到tz所指的结构中

    timeval结构定义为: struct timeval {

    long tv_sec; /*秒*/

    long tv_usec; /*微秒*/

    };

    timezone 结构定义为: struct timezone {

    int tz_minuteswest; /*和Greenwich 时间差了多少分钟*/

    int tz_dsttime; /*日光节约时间的状态*/

    };

    ctime

    原型:char *ctime(const time_t *timep);

    将参数timep所指的time_t结构中的信息转换成真实世界所使用的时间日期表示方法,然后将结果以字符串形态返回

    此函数已经由时区转换成当地时间,字符串格式为Wed Jun 30 21 :49 :08 1993

    asctime

    原型:char * asctime(const struct tm * timeptr);

    将参数timeptr所指的tm结构中的信息转换成真实世界所使用的时间日期表示方法,然后将结果以字符串形态返回

    此函数已经由时区转换成当地时间,字符串格式为: Wed Jun 30 21:49:08 1993\n

    若再调用相关的时间日期函数,此字符串可能会被破坏。此函数与ctime不同处在于传入的参数是不同的结构

    gmtime

    原型:struct tm* gmtime(const time_t*timep);

    将参数timep 所指的time_t 结构中的信息转换成真实世界所使用的时间日期表示方法,然后将结果由结构tm返回

    settimeofday

    原型:int settimeofday ( const struct timeval *tv,const struct timezone *tz);

    把目前时间设成由tv所指的结构信息,当地时区信息则设成tz所指的结构

    注意,只有root权限才能使用此函数修改时间

    更多详细信息请使用man手册。

    获取精确到毫秒的时间

    可以结合time, localtime, strftime得到本地时间,精确到秒。代码如下:

    static string CurrentLocalTime(void)

    {

    time_t t; //秒时间

    tm *local; //本地时间

    char buf[128] = {0};

    t = time(NULL); //获取目前秒时间

    local = localtime(&t); //转为本地时间,注意,该函数非线程安全,下面的例子会使用线程安全函数localtime_r

    strftime(buf, 64, "%Y-%m-%d %H:%M:%S", local); //根据需要自定义格式

    return buf;

    }

    要想得到精确到毫秒的时间,就需要使用gettimeofday了。代码如下:

    /**

    * @name: GetLocalTimeWithMs

    * @msg: 获取本地时间,精确到毫秒

    * @param {type}

    * @return: string字符串,格式为YYYYMMDDHHMMSSsss,如:20190710130510368

    */

    static string GetLocalTimeWithMs(void)

    {

    string defaultTime = "19700101000000000";

    try

    {

    struct timeval curTime;

    gettimeofday(&curTime, NULL);

    int milli = curTime.tv_usec / 1000;

    char buffer[80] = {0};

    struct tm nowTime;

    localtime_r(&curTime.tv_sec, &nowTime);//把得到的值存入临时分配的内存中,线程安全

    strftime(buffer, sizeof(buffer), "%Y%m%d%H%M%S", &nowTime);

    char currentTime[84] = {0};

    snprintf(currentTime, sizeof(currentTime), "%s%03d", buffer, milli);

    return currentTime;

    }

    catch(const std::exception& e)

    {

    return defaultTime;

    }

    catch (...)

    {

    return defaultTime;

    }

    }

    得到字符串表示的本地时间信息后,可根据需要对字符串进行操作,简单方便。

    c11获取时间戳

    c11提供了chrono,专门用来处理时间相关任务。它是子命名空间,位于std下。详细内容可以参考 std::chrono。

    这里介绍一下常用的两种场景:获取当前时间戳和计算时间跨度(可以用来计算某段程序的耗时)。

    获取当前时间戳

    // get current local time stamp

    int64_t getCurrentLocalTimeStamp()

    {

    std::chrono::time_point<:chrono::system_clock std::chrono::milliseconds> tp = std::chrono::time_point_cast<:chrono::milliseconds>(std::chrono::system_clock::now());

    auto tmp = std::chrono::duration_cast<:chrono::milliseconds>(tp.time_since_epoch());

    return tmp.count();

    // return std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count();

    }

    其中,system_clock是系统级的时钟,能够获取当前的 time_point。它的 now 静态成员方法用来获取当前时间。

    time_point 的 time_since_epoch 成员方法获取 1970 以来的时间。

    然后通过 time_point_cast 或者 duration_cast 的 count 方法获取具体时间。

    获取时间跨度

    int countTimeConsume()

    {

    using namespace std::chrono;

    high_resolution_clock::time_point t1 = high_resolution_clock::now();

    std::cout << "printing out 1000 stars...\n";

    for (int i = 0; i < 1000; ++i)

    std::cout << "*";

    std::cout << std::endl;

    high_resolution_clock::time_point t2 = high_resolution_clock::now();

    duration time_span = t2 - t1;

    std::cout << "It took me " << time_span.count() << " milliseconds.";

    std::cout << std::endl;

    return 0;

    }

    关于 system_clock、steady_clock、high_resolution_clock 的具体说明及区别,可能参考Difference between std::system_clock and std::steady_clock。

    总结

    本地时间的获取在各种程序中使用率较高,可以放在项目的util中,供所有代码使用。

    由于还没有理解透彻,不当之处请不吝指出哈。

    展开全文
  • C++在linux环境下获取毫秒、微妙级别时间一、时间单位简介:1秒 = 1000毫秒1秒 = 1000000微秒1秒 = 1000000000纳秒二、简介:C++中需要获取当前的时间的秒数和微秒数,需要用到gettimeofday()函数,该函数需要引入的...

    C++在linux环境下获取毫秒、微妙级别时间

    一、时间单位简介:

    1秒  = 1000毫秒

    1秒  = 1000000微秒

    1秒  = 1000000000纳秒

    二、简介:

    C++中需要获取当前的时间的秒数和微秒数,需要用到gettimeofday()函数,该函数需要引入的头文件是 “sys/time.h ”。

    函数说明int gettimeofday (struct timeval * tv, struct timezone * tz)    1、返回值:该函数成功时返回0,失败时返回-1

    2、参数

    struct timeval{

    long tv_sec;       //秒

    long tv_usec;    //微秒

    };

    struct timezone

    {

    int tz_minuteswest;     //和Greenwich 时间差了多少分钟

    int tz_dsttime;             //日光节约时间的状态

    };

    三、实例

    #include

    #include

    using namespace std;

    int main(int argc ,char *argv[]){

    //get time ms and us    struct timeval tv;

    struct timezone tz;

    gettimeofday(&tv,&tz);

    cout << "second : \t" << tv.tv_sec << endl; //秒

    cout << "millisecond : \t" << tv.tv_sec*1000 + tv.tv_usec/1000 << endl; // 毫秒

    cout << "micronsecond : \t" << tv.tv_sec*1000000 +tv.tv_usec <

    }

    展开全文
  • Linux获取毫秒为单位的当前时间

    千次阅读 2019-01-06 18:43:04
    通过gettimeofday函数只能获取到秒和微秒,获取到的秒是从1970年1月1日到当前的时间,而获取到的微秒只有六位数,所以要想得到以毫秒为单位的系统时间须将它俩整合起来。   #include &lt;stdio.h&gt; #...

           通过gettimeofday函数只能获取到秒和微秒,获取到的秒是从1970年1月1日到当前的时间,而获取到的微秒只有六位数,所以要想得到以毫秒为单位的系统时间须将它俩整合起来。

     

    #include <stdio.h>
    #include <sys/time.h>
    #include <stdlib.h>
    #include <string.h>

    long getCurrentTimeMsec()
    {
            int i = 0;
            long msec = 0;
            char str[20] = {0};
            struct timeval stuCurrentTime;

            gettimeofday(&stuCurrentTime, NULL);
            sprintf(str, "%ld%03ld", stuCurrentTime.tv_sec, (stuCurrentTime.tv_usec)/1000);

            for (i = 0; i < strlen(str); i++)
            {
                msec = msec * 10 + (str[i] - '0');        
            }

            return msec;
    }

    int main()
    {
            printf("msec:%ld\n", getCurrentTimeMsec());

            return 0;
    }

            stuCurrentTime.tv_sec获取到的是秒,(stuCurrentTime.tv_usec)/1000获取到的是毫秒,通过sprintf()函数将它们合成以毫秒单位的时间,但此时它们是字符串。所以通过for()循环里边的msec= msec* 10 + (str[i] - '0')语句,将字符串转换成长整型,即可以得到以毫秒为单位的时间。如此,还可以通过getCurrentTimeMsec()函数来计算以毫秒为单位的时间差,从而在代码中实现自己所需的功能。

           

     

     

     

     

     

     

           

    展开全文
  • 在Ubuntu上,这工作输出的时间以秒为单位,以小数点后的位置为微秒(包括尾随的新行) sudo apt-get install adjtimex adjtimex -p | awk '/raw time:/ { print $6 }' 我不会在Ubuntu上做这个。 我会用date +%s%N

    在大多数情况下,其他答案可能就足够了,但是当我在busybox系统上遇到问题时,我想我会增加2分钱。

    有问题的系统不支持%N格式选项,也没有python或perl解释器。

    我们(多谢戴夫!)想到了这个:

    adjtimex | awk '/(time.tv_sec|time.tv_usec):/ { printf("%06d", $2) }'

    它从adjtimex的输出(通常用于设置系统时钟的选项)中提取秒和微秒,并在没有新行的情况下打印它们(因此它们被粘在一起)。 请注意,微秒字段必须用零预填充,但不会影响长于6位的秒字段。 从这应该是微不足道的微秒转换为毫秒。

    如果你需要一个新的行(可能因为它看起来更好),然后尝试

    adjtimex | awk '/(time.tv_sec|time.tv_usec):/ { printf("%06d", $2) }' && printf "\n"

    还要注意,这需要使用adjtimex和awk 。 如果没有,那么可以用busybox指向他们

    ln -s /bin/busybox ./adjtimex ln -s /bin/busybox ./awk

    然后再拨打上面的

    ./adjtimex | ./awk '/(time.tv_sec|time.tv_usec):/ { printf("%06d", $2) }'

    或者当然你可以把它们放在你的PATH

    编辑:

    上面的工作在我的busybox设备上。 在Ubuntu上,我尝试了同样的事情,并意识到adjtimex有不同的版本。 在Ubuntu上,这工作输出的时间以秒为单位,以小数点后的位置为微秒(包括尾随的新行)

    sudo apt-get install adjtimex adjtimex -p | awk '/raw time:/ { print $6 }'

    我不会在Ubuntu上做这个。 我会用date +%s%N

    展开全文
  • On Windows, clock() returns the time in milliseconds, but on this Linux box I'm working on, it rounds it to the nearest 1000 so the precision is only to the "second" level and not to the milliseconds ...
  • #include <iostream> #include <sys/time.h> int main(){ struct timeval start, end; double t1, t2; gettimeofday(&start, NULL); /* to do something */ ...
  • Linux获取毫秒时间

    万次阅读 2010-03-03 18:58:00
    Linux获取毫秒时间Moakap在软件设计中经常会用到关于时间的处理,用来计算语句、函数的执行时间,这时就需要精确到毫秒甚至是微妙的时间。 int gettimeofday(structtimeval *tv, struct timezone *tz);int ...
  • Linux获取毫秒时间

    万次阅读 2012-08-22 19:46:15
    Linux获取毫秒时间差  使用Linux的gettimeofday函数可以达到这个目的  其中t1=t_start.tv_sec是公元1970年至今的时间(换算为秒)  t2=t_start.tv_usec是当前秒数下的微妙数  所以将t1*1000+t2/1000...
  • //转换时区,北京时间+8小时 auto mTime = std::chrono::milliseconds(milli); auto tp=std::chrono::time_point(mTime); auto tt = std::chrono::system_clock::to_time_t(tp); std::tm* now = std::gmtime(&tt); ...
  • #include #include #include void sysLocalTime(){time_t timesec;struct tm *p;time(×ec);p = localtime(×ec);printf("%d%d%d%d%d%d\n", 1900+p->tm_year, 1+p->tm_mon, p->tm_mday, ...
  • Linux获取毫秒时间

    千次阅读 2013-05-07 20:04:49
    #include long __GetTime() { struct timeval iTime; gettimeofday(&iTime, NULL); long lTime = ((long) iTime.tv_sec) * 1000000 + (long) iTime.tv_usec; return lTime; }
  • Linux c++获取本地毫秒级精确时间

    千次阅读 2019-07-15 15:14:08
    Linux c/c++中提供了很多操作时间的库函数,这里简要介绍。 使用头文件 #include <time.h> 常用的时间函数包括以下: time 原型:time_t time(time_t *t); 返回从公元1970年1月1日的UTC时间从0时0...
  • #include #include #include void sysLocalTime(void){time_t timesec;struct tm *t;time(&timesec);t = localtime(&timesec);printf("%d-%d-%d %d:%d:%d", 1900+t->tm_year, 1+t->...
  • How do I get the current time on Linux in milliseconds?解决方案This can be achieved using the POSIX clock_gettime function.In the current version of POSIX, gettimeofday is marked obsolete. This means ...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 210
精华内容 84
关键字:

linux获取时间毫秒

linux 订阅