Date and time utilities

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
(C++11)
 wall clock time from the system-wide realtime clock
(class)
(C++11)
 monotonic clock that will never be adjusted
(class)
(C++11)
 the clock with the shortest tick period available
(class)
(C++20)
 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)
(C++20)
 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
(C++11)
 a point in time
(class template)
(C++20)
 traits class defining how to convert time points of one clock to another
(class template)
(C++20)
 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
(C++20)
 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)
(C++20)
 represents the n-th weekday of a month
(class)
(C++20)
 represents the last weekday of a month
(class)
(C++20)
 represents a specific day of a specific month
(class)
(C++20)
 represents the last day of a specific month
(class)
(C++20)
 represents the n-th weekday of a specific month
(class)
(C++20)
 represents the last weekday of a specific month
(class)
(C++20)
 represents a specific month of a specific year
(class)
(C++20)
 represents a specific year, month, and day
(class)
(C++20)
 represents the last day of a specific year and month
(class)
(C++20)
 represents the n-th weekday of a specific year and month
(class)
(C++20)
 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)
(C++20)
 accesses and controls the global time zone database information
(function)
(C++20)
 locates a time_zone based on its name
(function)
(C++20)
 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)
(C++20)
 represents information about a local time to UNIX time conversion
(class)
(C++20)
 selects how an ambiguous local time should be resolved
(enum)
(C++20)
 traits class for time zone pointers used by zoned_time
(class template)
(C++20)
 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)
(C++20)
 exception thrown to report that a local time is nonexistent
(class)
(C++20)
 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

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/chrono