##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Standard library header <chrono>

From cppreference.com
< cpp‎ | header

This header is part of the date and time library.

### [edit] Classes

Defined in namespace `std::chrono`
duration (C++11) | a time interval (class template) [edit]
system_clock (C++11) | wall clock time from the system-wide realtime clock (class) [edit]
steady_clock (C++11) | monotonic clock that will never be adjusted (class) [edit]
high_resolution_clock (C++11) | the clock with the shortest tick period available (class) [edit]
time_point (C++11) | a point in time (class template) [edit]
treat_as_floating_point | indicates that a duration is convertible to duration with different tick period (class template)
duration_values | constructs zero, min, and max values of a tick count of given type (class template)
##### Convenience Typedefs
Defined in namespace `std::chrono`
std::chrono::nanoseconds | duration type with Period std::nano
std::chrono::microseconds | duration type with Period std::micro
std::chrono::milliseconds | duration type with Period std::milli
std::chrono::seconds | duration type with Period std::ratio<1>
std::chrono::minutes | duration type with Period std::ratio<60>
std::chrono::hours | duration type with Period std::ratio<3600>
##### Specializations
Defined in namespace `std`
std::common_type<std::chrono::duration> | specializes the std::common_type trait (class template specialization) [edit]
std::common_type<std::chrono::time_point> | specializes the std::common_type trait (class template specialization) [edit]

### [edit] Functions

##### Duration
Defined in namespace `std::chrono`
operator+operator-operator*operator/operator% | implements arithmetic operations with durations as arguments (function template) [edit]
operator==operator!=operator<operator<=operator>operator>= | compares two durations (function template) [edit]
duration_cast | converts a duration to another, with a different tick interval (function template) [edit]
##### Time point
Defined in namespace `std::chrono`
operator+operator- | modifies the time point by the given duration (function template) [edit]
operator==operator!=operator<operator<=operator>operator>= | compares two time points (function template) [edit]
time_point_cast | converts a time point to another time point on the same clock, with a different duration (function template) [edit]

### [edit] Synopsis

    namespace std {
    namespace chrono {

        // class template duration
        template <class Rep, class Period = ratio<1> > class duration;

        // class template time_point
        template <class Clock, class Duration = typename Clock::duration> class time_point;

    } // namespace chrono

    // common_type specializations
    template <class Rep1, class Period1, class Rep2, class Period2>
        struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>;

    template <class Clock, class Duration1, class Duration2>
        struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>;

    namespace chrono {

        // customization traits
        template <class Rep> struct treat_as_floating_point;
        template <class Rep> struct duration_values;

        // duration arithmetic
        template <class Rep1, class Period1, class Rep2, class Period2>
            typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
            constexpr operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
        template <class Rep1, class Period1, class Rep2, class Period2>
            typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
            constexpr operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
        template <class Rep1, class Period, class Rep2>
            duration<typename common_type<Rep1, Rep2>::type, Period>
            constexpr operator*(const duration<Rep1, Period>& d, const Rep2& s);
        template <class Rep1, class Rep2, class Period>
            duration<typename common_type<Rep1, Rep2>::type, Period>
            constexpr operator*(const Rep1& s, const duration<Rep2, Period>& d);
        template <class Rep1, class Period, class Rep2>
            duration<typename common_type<Rep1, Rep2>::type, Period>
            constexpr operator/(const duration<Rep1, Period>& d, const Rep2& s);
        template <class Rep1, class Period1, class Rep2, class Period2>
            typename common_type<Rep1, Rep2>::type
            constexpr operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
        template <class Rep1, class Period, class Rep2>
            duration<typename common_type<Rep1, Rep2>::type, Period>
            constexpr operator%(const duration<Rep1, Period>& d, const Rep2& s);
        template <class Rep1, class Period1, class Rep2, class Period2>
            typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
            constexpr operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

        // duration comparisons
        template <class Rep1, class Period1, class Rep2, class Period2>
            constexpr bool operator==(const duration<Rep1, Period1>& lhs,
                                        const duration<Rep2, Period2>& rhs);
        template <class Rep1, class Period1, class Rep2, class Period2>
            constexpr bool operator!=(const duration<Rep1, Period1>& lhs,
                                        const duration<Rep2, Period2>& rhs);
        template <class Rep1, class Period1, class Rep2, class Period2>
            constexpr bool operator< (const duration<Rep1, Period1>& lhs,
                                        const duration<Rep2, Period2>& rhs);
        template <class Rep1, class Period1, class Rep2, class Period2>
            constexpr bool operator<=(const duration<Rep1, Period1>& lhs,
                                        const duration<Rep2, Period2>& rhs);
        template <class Rep1, class Period1, class Rep2, class Period2>
            constexpr bool operator> (const duration<Rep1, Period1>& lhs,
                                        const duration<Rep2, Period2>& rhs);
        template <class Rep1, class Period1, class Rep2, class Period2>
            constexpr bool operator>=(const duration<Rep1, Period1>& lhs,
                                        const duration<Rep2, Period2>& rhs);

        // duration_cast
        template <class ToDuration, class Rep, class Period>
            constexpr ToDuration duration_cast(const duration<Rep, Period>& d);

        // convenience typedefs
        typedef duration</*signed integer type of at least 64 bits*/, nano>        nanoseconds;
        typedef duration</*signed integer type of at least 55 bits*/, micro>       microseconds;
        typedef duration</*signed integer type of at least 45 bits*/, milli>       milliseconds;
        typedef duration</*signed integer type of at least 35 bits*/ >             seconds;
        typedef duration</*signed integer type of at least 29 bits*/, ratio< 60>>  minutes;
        typedef duration</*signed integer type of at least 23 bits*/, ratio<3600>> hours;

        // time_point arithmetic
        template <class Clock, class Duration1, class Rep2, class Period2>
            time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
            operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
        template <class Rep1, class Period1, class Clock, class Duration2>
            time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
            operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
        template <class Clock, class Duration1, class Rep2, class Period2>
            time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
            operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
        template <class Clock, class Duration1, class Duration2>
            typename common_type<Duration1, Duration2>::type
            operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);

        // time_point comparisons
        template <class Clock, class Duration1, class Duration2>
            bool operator==(const time_point<Clock, Duration1>& lhs,
                            const time_point<Clock, Duration2>& rhs);
        template <class Clock, class Duration1, class Duration2>
            bool operator!=(const time_point<Clock, Duration1>& lhs,
                            const time_point<Clock, Duration2>& rhs);
        template <class Clock, class Duration1, class Duration2>
            bool operator< (const time_point<Clock, Duration1>& lhs,
                            const time_point<Clock, Duration2>& rhs);
        template <class Clock, class Duration1, class Duration2>
            bool operator<=(const time_point<Clock, Duration1>& lhs,
                            const time_point<Clock, Duration2>& rhs);
        template <class Clock, class Duration1, class Duration2>
            bool operator> (const time_point<Clock, Duration1>& lhs,
                            const time_point<Clock, Duration2>& rhs);
        template <class Clock, class Duration1, class Duration2>
            bool operator>=(const time_point<Clock, Duration1>& lhs,
                            const time_point<Clock, Duration2>& rhs);

        // time_point_cast
        template <class ToDuration, class Clock, class Duration>
            time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);

        // clocks
        class system_clock;
        class steady_clock;
        class high_resolution_clock;

    } // namespace chrono
    }// namespace std

| This section is incomplete Reason: Class synopses

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/header/chrono&oldid=67019"
Category:

- Todo with reason