Date and time utilities

From cppreference.com
< cpp
 
 
 
Date and time utilities
(C++11)
(C++11)
Clocks
(C++20)
                                                  
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
Calendars
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
Time zones
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
C-style date and time
 

C++ includes support for two types of time manipulation:

  • The chrono library, a flexible collection of types that track time with varying degrees of precision (e.g. std::chrono::time_point).
  • C-style date and time library (e.g. std::time)

std::chrono library

The chrono library defines three main types as well as utility functions and common typedefs.

  • clocks
  • time points
  • durations

Clocks

A clock consists of a starting point (or epoch) and a tick rate. For example, a clock may have an epoch of January 1, 1970 and tick every second. C++ defines several clock types:

Defined in header <chrono>
Defined in namespace std::chrono
wall clock time from the system-wide realtime clock
(class)
monotonic clock that will never be adjusted
(class)
the clock with the shortest tick period available
(class)
determines if a type is a Clock
(class template) (variable template)
(C++20)
Clock for Coordinated Universal Time (UTC)
(class)
(C++20)
Clock for International Atomic Time (TAI)
(class)
(C++20)
Clock for GPS time
(class)
Clock used for file time
(typedef)
(C++20)
pseudo-clock representing local time
(class)

Time point

A time point is a duration of time that has passed since the epoch of a specific clock.

Defined in header <chrono>
Defined in namespace std::chrono
a point in time
(class template)
traits class defining how to convert time points of one clock to another
(class template)
convert time points of one clock to another
(function template)

Duration

A duration consists of a span of time, defined as some number of ticks of some time unit. For example, "42 seconds" could be represented by a duration consisting of 42 ticks of a 1-second time unit.

Defined in header <chrono>
Defined in namespace std::chrono
(C++11)
a time interval
(class template)

Time of day

time_of_day splits a duration representing time elapsed since midnight into hours, minutes, seconds, and fractional seconds, as applicable. It is primarily a formatting tool.

Defined in header <chrono>
Defined in namespace std::chrono
represents a time of day
(class template)

Calendar

Defined in header <chrono>
Defined in namespace std::chrono
(C++20)
tag class indicating the last day or weekday in a month
(class)
(C++20)
represents a day of a month
(class)
(C++20)
represents a month of a year
(class)
(C++20)
represents a year in the Gregorian calendar
(class)
(C++20)
represents a day of the week in the Gregorian calendar
(class)
represents the n-th weekday of a month
(class)
represents the last weekday of a month
(class)
(C++20)
represents a specific day of a specific month
(class)
represents the last day of a specific month
(class)
represents the n-th weekday of a specific month
(class)
represents the last weekday of a specific month
(class)
represents a specific month of a specific year
(class)
represents a specific year, month, and day
(class)
represents the last day of a specific year and month
(class)
represents the n-th weekday of a specific year and month
(class)
represents the last weekday of a specific year and month
(class)
(C++20)
conventional syntax for Gregorian calendar date creation
(function)

Time zone

Defined in header <chrono>
Defined in namespace std::chrono
(C++20)
describes a copy of the IANA time zone database
(class)
(C++20)
represents a linked list of tzdb
(class)
accesses and controls the global time zone database information
(function)
locates a time_zone based on its name
(function)
returns the current time_zone
(function)
(C++20)
represents a time zone
(class)
(C++20)
represents information about a time zone at a particular time point
(class)
represents information about a local time to UNIX time conversion
(class)
(C++20)
selects how an ambiguous local time should be resolved
(enum)
traits class for time zone pointers used by zoned_time
(class template)
represents a time zone and a time point
(class)
(C++20)
contains information about a leap second insertion
(class)
(C++20)
represents an alternative name for a time zone
(class)
exception thrown to report that a local time is nonexistent
(class)
exception thrown to report that a local time is ambiguous
(class)

chrono I/O

Defined in header <chrono>
Defined in namespace std::chrono
(C++20)
formats a streamable chrono object for insertion
(function template)
(C++20)
parses a chrono object from a stream
(function template)


C-style date and time library

Also provided are the C-style date and time functions, such as std::time_t, std::difftime, and CLOCKS_PER_SEC.

Example

This example displays information about the execution time of a function call:

#include <iostream>
#include <chrono>
#include <ctime>
 
long fibonacci(unsigned n)
{
    if (n < 2) return n;
    return fibonacci(n-1) + fibonacci(n-2);
}
 
int main()
{
    auto start = std::chrono::system_clock::now();
    std::cout << "f(42) = " << fibonacci(42) << '\n';
    auto end = std::chrono::system_clock::now();
 
    std::chrono::duration<double> elapsed_seconds = end-start;
    std::time_t end_time = std::chrono::system_clock::to_time_t(end);
 
    std::cout << "finished computation at " << std::ctime(&end_time)
              << "elapsed time: " << elapsed_seconds.count() << "s\n";
}

Possible output:

f(42) = 267914296
finished computation at Mon Oct  2 00:59:08 2017
elapsed time: 1.88232s