27 Time library [time]

27.8 The civil calendar [time.cal]

27.8.1 In general [time.cal.general]

1
#
The types in [time.cal] describe the civil (Gregorian) calendar and its relationship to sys_­days and local_­days.

27.8.2 Class last_­spec [time.cal.last]

namespace std::chrono { struct last_spec { explicit last_spec() = default; }; }
1
#
The type last_­spec is used in conjunction with other calendar types to specify the last in a sequence.
For example, depending on context, it can represent the last day of a month, or the last day of the week of a month.

27.8.3 Class day [time.cal.day]

27.8.3.1 Overview [time.cal.day.overview]

namespace std::chrono { class day { unsigned char d_; // exposition only public: day() = default; constexpr explicit day(unsigned d) noexcept; constexpr day& operator++() noexcept; constexpr day operator++(int) noexcept; constexpr day& operator--() noexcept; constexpr day operator--(int) noexcept; constexpr day& operator+=(const days& d) noexcept; constexpr day& operator-=(const days& d) noexcept; constexpr explicit operator unsigned() const noexcept; constexpr bool ok() const noexcept; }; }
1
#
day represents a day of a month.
It normally holds values in the range 1 to 31, but may hold non-negative values outside this range.
It can be constructed with any unsigned value, which will be subsequently truncated to fit into day's unspecified internal storage.
day meets the Cpp17EqualityComparable (Table 25) and Cpp17LessThanComparable (Table 26) requirements, and participates in basic arithmetic with days objects, which represent a difference between two day objects.
2
#
day is a trivially copyable and standard-layout class type.

27.8.3.2 Member functions [time.cal.day.members]

🔗
constexpr explicit day(unsigned d) noexcept;
1
#
Effects: Initializes d_­ with d.
The value held is unspecified if d is not in the range [0, 255].
🔗
constexpr day& operator++() noexcept;
2
#
Effects: ++d_­.
3
#
Returns: *this.
🔗
constexpr day operator++(int) noexcept;
4
#
Effects: ++(*this).
5
#
Returns: A copy of *this as it existed on entry to this member function.
🔗
constexpr day& operator--() noexcept;
6
#
Effects: Equivalent to: --d_­.
7
#
Returns: *this.
🔗
constexpr day operator--(int) noexcept;
8
#
Effects: --(*this).
9
#
Returns: A copy of *this as it existed on entry to this member function.
🔗
constexpr day& operator+=(const days& d) noexcept;
10
#
Effects: *this = *this + d.
11
#
Returns: *this.
🔗
constexpr day& operator-=(const days& d) noexcept;
12
#
Effects: *this = *this - d.
13
#
Returns: *this.
🔗
constexpr explicit operator unsigned() const noexcept;
14
#
Returns: d_­.
🔗
constexpr bool ok() const noexcept;
15
#
Returns: 1 <= d_­ && d_­ <= 31.

27.8.3.3 Non-member functions [time.cal.day.nonmembers]

🔗
constexpr bool operator==(const day& x, const day& y) noexcept;
1
#
Returns: unsigned{x} == unsigned{y}.
🔗
constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
2
#
Returns: unsigned{x} <=> unsigned{y}.
🔗
constexpr day operator+(const day& x, const days& y) noexcept;
3
#
Returns: day(unsigned{x} + y.count()).
🔗
constexpr day operator+(const days& x, const day& y) noexcept;
4
#
Returns: y + x.
🔗
constexpr day operator-(const day& x, const days& y) noexcept;
5
#
Returns: x + -y.
🔗
constexpr days operator-(const day& x, const day& y) noexcept;
6
#
Returns: days{int(unsigned{x}) - int(unsigned{y})}.
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const day& d);
7
#
Effects: Equivalent to: return os << (d.ok() ? format(STATICALLY-WIDEN<charT>("{:%d}"), d) : format(STATICALLY-WIDEN<charT>("{:%d} is not a valid day"), d));
🔗
template<class charT, class traits, class Alloc = allocator<charT>> basic_istream<charT, traits>& from_stream(basic_istream<charT, traits>& is, const charT* fmt, day& d, basic_string<charT, traits, Alloc>* abbrev = nullptr, minutes* offset = nullptr);
8
#
Effects: Attempts to parse the input stream is into the day d using the format flags given in the NTCTS fmt as specified in [time.parse].
If the parse fails to decode a valid day, is.setstate(ios_­base​::​failbit) is called and d is not modified.
If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
9
#
Returns: is.
🔗
constexpr chrono::day operator""d(unsigned long long d) noexcept;
10
#
Returns: day{static_­cast<unsigned>(d)}.

27.8.4 Class month [time.cal.month]

27.8.4.1 Overview [time.cal.month.overview]

namespace std::chrono { class month { unsigned char m_; // exposition only public: month() = default; constexpr explicit month(unsigned m) noexcept; constexpr month& operator++() noexcept; constexpr month operator++(int) noexcept; constexpr month& operator--() noexcept; constexpr month operator--(int) noexcept; constexpr month& operator+=(const months& m) noexcept; constexpr month& operator-=(const months& m) noexcept; constexpr explicit operator unsigned() const noexcept; constexpr bool ok() const noexcept; }; }
1
#
month represents a month of a year.
It normally holds values in the range 1 to 12, but may hold non-negative values outside this range.
It can be constructed with any unsigned value, which will be subsequently truncated to fit into month's unspecified internal storage.
month meets the Cpp17EqualityComparable (Table 25) and Cpp17LessThanComparable (Table 26) requirements, and participates in basic arithmetic with months objects, which represent a difference between two month objects.
2
#
month is a trivially copyable and standard-layout class type.

27.8.4.2 Member functions [time.cal.month.members]

🔗
constexpr explicit month(unsigned m) noexcept;
1
#
Effects: Initializes m_­ with m.
The value held is unspecified if m is not in the range [0, 255].
🔗
constexpr month& operator++() noexcept;
2
#
Effects: *this += months{1}.
3
#
Returns: *this.
🔗
constexpr month operator++(int) noexcept;
4
#
Effects: ++(*this).
5
#
Returns: A copy of *this as it existed on entry to this member function.
🔗
constexpr month& operator--() noexcept;
6
#
Effects: *this -= months{1}.
7
#
Returns: *this.
🔗
constexpr month operator--(int) noexcept;
8
#
Effects: --(*this).
9
#
Returns: A copy of *this as it existed on entry to this member function.
🔗
constexpr month& operator+=(const months& m) noexcept;
10
#
Effects: *this = *this + m.
11
#
Returns: *this.
🔗
constexpr month& operator-=(const months& m) noexcept;
12
#
Effects: *this = *this - m.
13
#
Returns: *this.
🔗
constexpr explicit operator unsigned() const noexcept;
14
#
Returns: m_­.
🔗
constexpr bool ok() const noexcept;
15
#
Returns: 1 <= m_­ && m_­ <= 12.

27.8.4.3 Non-member functions [time.cal.month.nonmembers]

🔗
constexpr bool operator==(const month& x, const month& y) noexcept;
1
#
Returns: unsigned{x} == unsigned{y}.
🔗
constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
2
#
Returns: unsigned{x} <=> unsigned{y}.
🔗
constexpr month operator+(const month& x, const months& y) noexcept;
3
#
Returns: month{modulo(static_cast<long long>(unsigned{x}) + (y.count() - 1), 12) + 1} where modulo(n, 12) computes the remainder of n divided by 12 using Euclidean division.
[Note 1:
Given a divisor of 12, Euclidean division truncates towards negative infinity and always produces a remainder in the range of [0, 11].
Assuming no overflow in the signed summation, this operation results in a month holding a value in the range [1, 12] even if !x.ok().
— end note]
[Example 1:
February + months{11} == January.
— end example]
🔗
constexpr month operator+(const months& x, const month& y) noexcept;
4
#
Returns: y + x.
🔗
constexpr month operator-(const month& x, const months& y) noexcept;
5
#
Returns: x + -y.
🔗
constexpr months operator-(const month& x, const month& y) noexcept;
6
#
Returns: If x.ok() == true and y.ok() == true, returns a value m in the range [months{0}, months{11}] satisfying y + m == x.
Otherwise the value returned is unspecified.
[Example 2:
January - February == months{11}.
— end example]
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const month& m);
7
#
Effects: Equivalent to: return os << (m.ok() ? format(os.getloc(), STATICALLY-WIDEN<charT>("{:%b}"), m) : format(os.getloc(), STATICALLY-WIDEN<charT>("{} is not a valid month"), static_cast<unsigned>(m)));
🔗
template<class charT, class traits, class Alloc = allocator<charT>> basic_istream<charT, traits>& from_stream(basic_istream<charT, traits>& is, const charT* fmt, month& m, basic_string<charT, traits, Alloc>* abbrev = nullptr, minutes* offset = nullptr);
8
#
Effects: Attempts to parse the input stream is into the month m using the format flags given in the NTCTS fmt as specified in [time.parse].
If the parse fails to decode a valid month, is.setstate(ios_­base​::​failbit) is called and m is not modified.
If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
9
#
Returns: is.

27.8.5 Class year [time.cal.year]

27.8.5.1 Overview [time.cal.year.overview]

namespace std::chrono { class year { short y_; // exposition only public: year() = default; constexpr explicit year(int y) noexcept; constexpr year& operator++() noexcept; constexpr year operator++(int) noexcept; constexpr year& operator--() noexcept; constexpr year operator--(int) noexcept; constexpr year& operator+=(const years& y) noexcept; constexpr year& operator-=(const years& y) noexcept; constexpr year operator+() const noexcept; constexpr year operator-() const noexcept; constexpr bool is_leap() const noexcept; constexpr explicit operator int() const noexcept; constexpr bool ok() const noexcept; static constexpr year min() noexcept; static constexpr year max() noexcept; }; }
1
#
year represents a year in the civil calendar.
It can represent values in the range [min(), max()].
It can be constructed with any int value, which will be subsequently truncated to fit into year's unspecified internal storage.
year meets the Cpp17EqualityComparable (Table 25) and Cpp17LessThanComparable (Table 26) requirements, and participates in basic arithmetic with years objects, which represent a difference between two year objects.
2
#
year is a trivially copyable and standard-layout class type.

27.8.5.2 Member functions [time.cal.year.members]

🔗
constexpr explicit year(int y) noexcept;
1
#
Effects: Initializes y_­ with y.
The value held is unspecified if y is not in the range [-32767, 32767].
🔗
constexpr year& operator++() noexcept;
2
#
Effects: ++y_­.
3
#
Returns: *this.
🔗
constexpr year operator++(int) noexcept;
4
#
Effects: ++(*this).
5
#
Returns: A copy of *this as it existed on entry to this member function.
🔗
constexpr year& operator--() noexcept;
6
#
Effects: --y_­.
7
#
Returns: *this.
🔗
constexpr year operator--(int) noexcept;
8
#
Effects: --(*this).
9
#
Returns: A copy of *this as it existed on entry to this member function.
🔗
constexpr year& operator+=(const years& y) noexcept;
10
#
Effects: *this = *this + y.
11
#
Returns: *this.
🔗
constexpr year& operator-=(const years& y) noexcept;
12
#
Effects: *this = *this - y.
13
#
Returns: *this.
🔗
constexpr year operator+() const noexcept;
14
#
Returns: *this.
🔗
constexpr year year::operator-() const noexcept;
15
#
Returns: year{-y_­}.
🔗
constexpr bool is_leap() const noexcept;
16
#
Returns: y_­ % 4 == 0 && (y_­ % 100 != 0 || y_­ % 400 == 0).
🔗
constexpr explicit operator int() const noexcept;
17
#
Returns: y_­.
🔗
constexpr bool ok() const noexcept;
18
#
Returns: min().y_­ <= y_­ && y_­ <= max().y_­.
🔗
static constexpr year min() noexcept;
19
#
Returns: year{-32767}.
🔗
static constexpr year max() noexcept;
20
#
Returns: year{32767}.

27.8.5.3 Non-member functions [time.cal.year.nonmembers]

🔗
constexpr bool operator==(const year& x, const year& y) noexcept;
1
#
Returns: int{x} == int{y}.
🔗
constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
2
#
Returns: int{x} <=> int{y}.
🔗
constexpr year operator+(const year& x, const years& y) noexcept;
3
#
Returns: year{int{x} + y.count()}.
🔗
constexpr year operator+(const years& x, const year& y) noexcept;
4
#
Returns: y + x.
🔗
constexpr year operator-(const year& x, const years& y) noexcept;
5
#
Returns: x + -y.
🔗
constexpr years operator-(const year& x, const year& y) noexcept;
6
#
Returns: years{int{x} - int{y}}.
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const year& y);
7
#
Effects: Equivalent to: return os << (y.ok() ? format(STATICALLY-WIDEN<charT>("{:%Y}"), y) : format(STATICALLY-WIDEN<charT>("{:%Y} is not a valid year"), y));
🔗
template<class charT, class traits, class Alloc = allocator<charT>> basic_istream<charT, traits>& from_stream(basic_istream<charT, traits>& is, const charT* fmt, year& y, basic_string<charT, traits, Alloc>* abbrev = nullptr, minutes* offset = nullptr);
8
#
Effects: Attempts to parse the input stream is into the year y using the format flags given in the NTCTS fmt as specified in [time.parse].
If the parse fails to decode a valid year, is.setstate(ios_­base​::​failbit) is called and y is not modified.
If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
9
#
Returns: is.
🔗
constexpr chrono::year operator""y(unsigned long long y) noexcept;
10
#
Returns: year{static_­cast<int>(y)}.

27.8.6 Class weekday [time.cal.wd]

27.8.6.1 Overview [time.cal.wd.overview]

namespace std::chrono { class weekday { unsigned char wd_; // exposition only public: weekday() = default; constexpr explicit weekday(unsigned wd) noexcept; constexpr weekday(const sys_days& dp) noexcept; constexpr explicit weekday(const local_days& dp) noexcept; constexpr weekday& operator++() noexcept; constexpr weekday operator++(int) noexcept; constexpr weekday& operator--() noexcept; constexpr weekday operator--(int) noexcept; constexpr weekday& operator+=(const days& d) noexcept; constexpr weekday& operator-=(const days& d) noexcept; constexpr unsigned c_encoding() const noexcept; constexpr unsigned iso_encoding() const noexcept; constexpr bool ok() const noexcept; constexpr weekday_indexed operator[](unsigned index) const noexcept; constexpr weekday_last operator[](last_spec) const noexcept; }; }
1
#
weekday represents a day of the week in the civil calendar.
It normally holds values in the range 0 to 6, corresponding to Sunday through Saturday, but it may hold non-negative values outside this range.
It can be constructed with any unsigned value, which will be subsequently truncated to fit into weekday's unspecified internal storage.
weekday meets the Cpp17EqualityComparable (Table 25) requirements.
[Note 1:
weekday is not Cpp17LessThanComparable because there is no universal consensus on which day is the first day of the week.
weekday's arithmetic operations treat the days of the week as a circular range, with no beginning and no end.
— end note]
2
#
weekday is a trivially copyable and standard-layout class type.

27.8.6.2 Member functions [time.cal.wd.members]

🔗
constexpr explicit weekday(unsigned wd) noexcept;
1
#
Effects: Initializes wd_­ with wd == 7 ? 0 : wd.
The value held is unspecified if wd is not in the range [0, 255].
🔗
constexpr weekday(const sys_days& dp) noexcept;
2
#
Effects: Computes what day of the week corresponds to the sys_­days dp, and initializes that day of the week in wd_­.
3
#
[Example 1:
If dp represents 1970-01-01, the constructed weekday represents Thursday by storing 4 in wd_­.
— end example]
🔗
constexpr explicit weekday(const local_days& dp) noexcept;
4
#
Effects: Computes what day of the week corresponds to the local_­days dp, and initializes that day of the week in wd_­.
5
#
Postconditions: The value is identical to that constructed from sys_­days{dp.time_­since_­epoch()}.
🔗
constexpr weekday& operator++() noexcept;
6
#
Effects: *this += days{1}.
7
#
Returns: *this.
🔗
constexpr weekday operator++(int) noexcept;
8
#
Effects: ++(*this).
9
#
Returns: A copy of *this as it existed on entry to this member function.
🔗
constexpr weekday& operator--() noexcept;
10
#
Effects: *this -= days{1}.
11
#
Returns: *this.
🔗
constexpr weekday operator--(int) noexcept;
12
#
Effects: --(*this).
13
#
Returns: A copy of *this as it existed on entry to this member function.
🔗
constexpr weekday& operator+=(const days& d) noexcept;
14
#
Effects: *this = *this + d.
15
#
Returns: *this.
🔗
constexpr weekday& operator-=(const days& d) noexcept;
16
#
Effects: *this = *this - d.
17
#
Returns: *this.
🔗
constexpr unsigned c_encoding() const noexcept;
18
#
Returns: wd_­.
🔗
constexpr unsigned iso_encoding() const noexcept;
19
#
Returns: wd_­ == 0u ? 7u : wd_­.
🔗
constexpr bool ok() const noexcept;
20
#
Returns: wd_­ <= 6.
🔗
constexpr weekday_indexed operator[](unsigned index) const noexcept;
21
#
Returns: {*this, index}.
🔗
constexpr weekday_last operator[](last_spec) const noexcept;
22
#
Returns: weekday_­last{*this}.

27.8.6.3 Non-member functions [time.cal.wd.nonmembers]

🔗
constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
1
#
Returns: x.wd_­ == y.wd_­.
🔗
constexpr weekday operator+(const weekday& x, const days& y) noexcept;
2
#
Returns: weekday{modulo(static_cast<long long>(x.wd_) + y.count(), 7)} where modulo(n, 7) computes the remainder of n divided by 7 using Euclidean division.
[Note 1:
Given a divisor of 7, Euclidean division truncates towards negative infinity and always produces a remainder in the range of [0, 6].
Assuming no overflow in the signed summation, this operation results in a weekday holding a value in the range [0, 6] even if !x.ok().
— end note]
[Example 1:
Monday + days{6} == Sunday.
— end example]
🔗
constexpr weekday operator+(const days& x, const weekday& y) noexcept;
3
#
Returns: y + x.
🔗
constexpr weekday operator-(const weekday& x, const days& y) noexcept;
4
#
Returns: x + -y.
🔗
constexpr days operator-(const weekday& x, const weekday& y) noexcept;
5
#
Returns: If x.ok() == true and y.ok() == true, returns a value d in the range [days{0}, days{6}] satisfying y + d == x.
Otherwise the value returned is unspecified.
[Example 2:
Sunday - Monday == days{6}.
— end example]
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const weekday& wd);
6
#
Effects: Equivalent to: return os << (wd.ok() ? format(os.getloc(), STATICALLY-WIDEN<charT>("{:%a}"), wd) : format(os.getloc(), STATICALLY-WIDEN<charT>("{} is not a valid weekday"), static_cast<unsigned>(wd.wd_)));
🔗
template<class charT, class traits, class Alloc = allocator<charT>> basic_istream<charT, traits>& from_stream(basic_istream<charT, traits>& is, const charT* fmt, weekday& wd, basic_string<charT, traits, Alloc>* abbrev = nullptr, minutes* offset = nullptr);
7
#
Effects: Attempts to parse the input stream is into the weekday wd using the format flags given in the NTCTS fmt as specified in [time.parse].
If the parse fails to decode a valid weekday, is.setstate(ios_­base​::​failbit) is called and wd is not modified.
If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
8
#
Returns: is.

27.8.7 Class weekday_­indexed [time.cal.wdidx]

27.8.7.1 Overview [time.cal.wdidx.overview]

namespace std::chrono { class weekday_indexed { chrono::weekday wd_; // exposition only unsigned char index_; // exposition only public: weekday_indexed() = default; constexpr weekday_indexed(const chrono::weekday& wd, unsigned index) noexcept; constexpr chrono::weekday weekday() const noexcept; constexpr unsigned index() const noexcept; constexpr bool ok() const noexcept; }; }
1
#
weekday_­indexed represents a weekday and a small index in the range 1 to 5.
This class is used to represent the first, second, third, fourth, or fifth weekday of a month.
2
#
[Note 1:
A weekday_­indexed object can be constructed by indexing a weekday with an unsigned.
— end note]
[Example 1: constexpr auto wdi = Sunday[2]; // wdi is the second Sunday of an as yet unspecified month static_assert(wdi.weekday() == Sunday); static_assert(wdi.index() == 2); — end example]
3
#
weekday_­indexed is a trivially copyable and standard-layout class type.

27.8.7.2 Member functions [time.cal.wdidx.members]

🔗
constexpr weekday_indexed(const chrono::weekday& wd, unsigned index) noexcept;
1
#
Effects: Initializes wd_­ with wd and index_­ with index.
The values held are unspecified if !wd.ok() or index is not in the range [0, 7].
🔗
constexpr chrono::weekday weekday() const noexcept;
2
#
Returns: wd_­.
🔗
constexpr unsigned index() const noexcept;
3
#
Returns: index_­.
🔗
constexpr bool ok() const noexcept;
4
#
Returns: wd_­.ok() && 1 <= index_­ && index_­ <= 5.

27.8.7.3 Non-member functions [time.cal.wdidx.nonmembers]

🔗
constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
1
#
Returns: x.weekday() == y.weekday() && x.index() == y.index().
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const weekday_indexed& wdi);
2
#
Effects: Equivalent to: auto i = wdi.index(); return os << (i >= 1 && i <= 5 ? format(os.getloc(), STATICALLY-WIDEN<charT>("{}[{}]"), wdi.weekday(), i) : format(os.getloc(), STATICALLY-WIDEN<charT>("{}[{} is not a valid index]"), wdi.weekday(), i));

27.8.8 Class weekday_­last [time.cal.wdlast]

27.8.8.1 Overview [time.cal.wdlast.overview]

namespace std::chrono { class weekday_last { chrono::weekday wd_; // exposition only public: constexpr explicit weekday_last(const chrono::weekday& wd) noexcept; constexpr chrono::weekday weekday() const noexcept; constexpr bool ok() const noexcept; }; }
1
#
weekday_­last represents the last weekday of a month.
2
#
[Note 1:
A weekday_­last object can be constructed by indexing a weekday with last.
— end note]
[Example 1: constexpr auto wdl = Sunday[last]; // wdl is the last Sunday of an as yet unspecified month static_assert(wdl.weekday() == Sunday); — end example]
3
#
weekday_­last is a trivially copyable and standard-layout class type.

27.8.8.2 Member functions [time.cal.wdlast.members]

🔗
constexpr explicit weekday_last(const chrono::weekday& wd) noexcept;
1
#
Effects: Initializes wd_­ with wd.
🔗
constexpr chrono::weekday weekday() const noexcept;
2
#
Returns: wd_­.
🔗
constexpr bool ok() const noexcept;
3
#
Returns: wd_­.ok().

27.8.8.3 Non-member functions [time.cal.wdlast.nonmembers]

🔗
constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
1
#
Returns: x.weekday() == y.weekday().
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const weekday_last& wdl);
2
#
Effects: Equivalent to: return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}[last]"), wdl.weekday());

27.8.9 Class month_­day [time.cal.md]

27.8.9.1 Overview [time.cal.md.overview]

namespace std::chrono { class month_day { chrono::month m_; // exposition only chrono::day d_; // exposition only public: month_day() = default; constexpr month_day(const chrono::month& m, const chrono::day& d) noexcept; constexpr chrono::month month() const noexcept; constexpr chrono::day day() const noexcept; constexpr bool ok() const noexcept; }; }
1
#
month_­day represents a specific day of a specific month, but with an unspecified year.
month_­day meets the Cpp17EqualityComparable (Table 25) and Cpp17LessThanComparable (Table 26) requirements.
2
#
month_­day is a trivially copyable and standard-layout class type.

27.8.9.2 Member functions [time.cal.md.members]

🔗
constexpr month_day(const chrono::month& m, const chrono::day& d) noexcept;
1
#
Effects: Initializes m_­ with m, and d_­ with d.
🔗
constexpr chrono::month month() const noexcept;
2
#
Returns: m_­.
🔗
constexpr chrono::day day() const noexcept;
3
#
Returns: d_­.
🔗
constexpr bool ok() const noexcept;
4
#
Returns: true if m_­.ok() is true, 1d <= d_­, and d_­ is less than or equal to the number of days in month m_­; otherwise returns false.
When m_­ == February, the number of days is considered to be 29.

27.8.9.3 Non-member functions [time.cal.md.nonmembers]

🔗
constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
1
#
Returns: x.month() == y.month() && x.day() == y.day().
🔗
constexpr strong_ordering operator<=>(const month_day& x, const month_day& y) noexcept;
2
#
Effects: Equivalent to: if (auto c = x.month() <=> y.month(); c != 0) return c; return x.day() <=> y.day();
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const month_day& md);
3
#
Effects: Equivalent to: return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}"), md.month(), md.day());
🔗
template<class charT, class traits, class Alloc = allocator<charT>> basic_istream<charT, traits>& from_stream(basic_istream<charT, traits>& is, const charT* fmt, month_day& md, basic_string<charT, traits, Alloc>* abbrev = nullptr, minutes* offset = nullptr);
4
#
Effects: Attempts to parse the input stream is into the month_­day md using the format flags given in the NTCTS fmt as specified in [time.parse].
If the parse fails to decode a valid month_­day, is.setstate(ios_­base​::​failbit) is called and md is not modified.
If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
5
#
Returns: is.

27.8.10 Class month_­day_­last [time.cal.mdlast]

namespace std::chrono { class month_day_last { chrono::month m_; // exposition only public: constexpr explicit month_day_last(const chrono::month& m) noexcept; constexpr chrono::month month() const noexcept; constexpr bool ok() const noexcept; }; }
1
#
month_­day_­last represents the last day of a month.
2
#
[Note 1:
A month_­day_­last object can be constructed using the expression m/last or last/m, where m is an expression of type month.
— end note]
[Example 1: constexpr auto mdl = February/last; // mdl is the last day of February of an as yet unspecified year static_assert(mdl.month() == February); — end example]
3
#
month_­day_­last is a trivially copyable and standard-layout class type.
🔗
constexpr explicit month_day_last(const chrono::month& m) noexcept;
4
#
Effects: Initializes m_­ with m.
🔗
constexpr month month() const noexcept;
5
#
Returns: m_­.
🔗
constexpr bool ok() const noexcept;
6
#
Returns: m_­.ok().
🔗
constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
7
#
Returns: x.month() == y.month().
🔗
constexpr strong_ordering operator<=>(const month_day_last& x, const month_day_last& y) noexcept;
8
#
Returns: x.month() <=> y.month().
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const month_day_last& mdl);
9
#
Effects: Equivalent to: return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/last"), mdl.month());

27.8.11 Class month_­weekday [time.cal.mwd]

27.8.11.1 Overview [time.cal.mwd.overview]

namespace std::chrono { class month_weekday { chrono::month m_; // exposition only chrono::weekday_indexed wdi_; // exposition only public: constexpr month_weekday(const chrono::month& m, const chrono::weekday_indexed& wdi) noexcept; constexpr chrono::month month() const noexcept; constexpr chrono::weekday_indexed weekday_indexed() const noexcept; constexpr bool ok() const noexcept; }; }
1
#
month_­weekday represents the weekday of a month, of an as yet unspecified year.
To do this the month_­weekday stores a month and a weekday_­indexed.
2
#
[Example 1: constexpr auto mwd = February/Tuesday[3]; // mwd is the third Tuesday of February of an as yet unspecified year static_assert(mwd.month() == February); static_assert(mwd.weekday_indexed() == Tuesday[3]); — end example]
3
#
month_­weekday is a trivially copyable and standard-layout class type.

27.8.11.2 Member functions [time.cal.mwd.members]

🔗
constexpr month_weekday(const chrono::month& m, const chrono::weekday_indexed& wdi) noexcept;
1
#
Effects: Initializes m_­ with m, and wdi_­ with wdi.
🔗
constexpr chrono::month month() const noexcept;
2
#
Returns: m_­.
🔗
constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
3
#
Returns: wdi_­.
🔗
constexpr bool ok() const noexcept;
4
#
Returns: m_­.ok() && wdi_­.ok().

27.8.11.3 Non-member functions [time.cal.mwd.nonmembers]

🔗
constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
1
#
Returns: x.month() == y.month() && x.weekday_­indexed() == y.weekday_­indexed().
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const month_weekday& mwd);
2
#
Effects: Equivalent to: return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}"), mwd.month(), mwd.weekday_indexed());

27.8.12 Class month_­weekday_­last [time.cal.mwdlast]

27.8.12.1 Overview [time.cal.mwdlast.overview]

namespace std::chrono { class month_weekday_last { chrono::month m_; // exposition only chrono::weekday_last wdl_; // exposition only public: constexpr month_weekday_last(const chrono::month& m, const chrono::weekday_last& wdl) noexcept; constexpr chrono::month month() const noexcept; constexpr chrono::weekday_last weekday_last() const noexcept; constexpr bool ok() const noexcept; }; }
1
#
month_­weekday_­last represents the last weekday of a month, of an as yet unspecified year.
To do this the month_­weekday_­last stores a month and a weekday_­last.
2
#
[Example 1: constexpr auto mwd = February/Tuesday[last]; // mwd is the last Tuesday of February of an as yet unspecified year static_assert(mwd.month() == February); static_assert(mwd.weekday_last() == Tuesday[last]); — end example]
3
#
month_­weekday_­last is a trivially copyable and standard-layout class type.

27.8.12.2 Member functions [time.cal.mwdlast.members]

🔗
constexpr month_weekday_last(const chrono::month& m, const chrono::weekday_last& wdl) noexcept;
1
#
Effects: Initializes m_­ with m, and wdl_­ with wdl.
🔗
constexpr chrono::month month() const noexcept;
2
#
Returns: m_­.
🔗
constexpr chrono::weekday_last weekday_last() const noexcept;
3
#
Returns: wdl_­.
🔗
constexpr bool ok() const noexcept;
4
#
Returns: m_­.ok() && wdl_­.ok().

27.8.12.3 Non-member functions [time.cal.mwdlast.nonmembers]

🔗
constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
1
#
Returns: x.month() == y.month() && x.weekday_­last() == y.weekday_­last().
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const month_weekday_last& mwdl);
2
#
Effects: Equivalent to: return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}"), mwdl.month(), mwdl.weekday_last());

27.8.13 Class year_­month [time.cal.ym]

27.8.13.1 Overview [time.cal.ym.overview]

namespace std::chrono { class year_month { chrono::year y_; // exposition only chrono::month m_; // exposition only public: year_month() = default; constexpr year_month(const chrono::year& y, const chrono::month& m) noexcept; constexpr chrono::year year() const noexcept; constexpr chrono::month month() const noexcept; constexpr year_month& operator+=(const months& dm) noexcept; constexpr year_month& operator-=(const months& dm) noexcept; constexpr year_month& operator+=(const years& dy) noexcept; constexpr year_month& operator-=(const years& dy) noexcept; constexpr bool ok() const noexcept; }; }
1
#
year_­month represents a specific month of a specific year, but with an unspecified day.
year_­month is a field-based time point with a resolution of months.
year_­month meets the Cpp17EqualityComparable (Table 25) and Cpp17LessThanComparable (Table 26) requirements.
2
#
year_­month is a trivially copyable and standard-layout class type.

27.8.13.2 Member functions [time.cal.ym.members]

🔗
constexpr year_month(const chrono::year& y, const chrono::month& m) noexcept;
1
#
Effects: Initializes y_­ with y, and m_­ with m.
🔗
constexpr chrono::year year() const noexcept;
2
#
Returns: y_­.
🔗
constexpr chrono::month month() const noexcept;
3
#
Returns: m_­.
🔗
constexpr year_month& operator+=(const months& dm) noexcept;
4
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
5
#
Effects: *this = *this + dm.
6
#
Returns: *this.
🔗
constexpr year_month& operator-=(const months& dm) noexcept;
7
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
8
#
Effects: *this = *this - dm.
9
#
Returns: *this.
🔗
constexpr year_month& operator+=(const years& dy) noexcept;
10
#
Effects: *this = *this + dy.
11
#
Returns: *this.
🔗
constexpr year_month& operator-=(const years& dy) noexcept;
12
#
Effects: *this = *this - dy.
13
#
Returns: *this.
🔗
constexpr bool ok() const noexcept;
14
#
Returns: y_­.ok() && m_­.ok().

27.8.13.3 Non-member functions [time.cal.ym.nonmembers]

🔗
constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
1
#
Returns: x.year() == y.year() && x.month() == y.month().
🔗
constexpr strong_ordering operator<=>(const year_month& x, const year_month& y) noexcept;
2
#
Effects: Equivalent to: if (auto c = x.year() <=> y.year(); c != 0) return c; return x.month() <=> y.month();
🔗
constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;
3
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
4
#
Returns: A year_­month value z such that z.ok() && z - ym == dm is true.
5
#
Complexity: with respect to the value of dm.
🔗
constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;
6
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
7
#
Returns: ym + dm.
🔗
constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;
8
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
9
#
Returns: ym + -dm.
🔗
constexpr months operator-(const year_month& x, const year_month& y) noexcept;
10
#
Returns: x.year() - y.year() + months{static_cast<int>(unsigned{x.month()}) - static_cast<int>(unsigned{y.month()})}
🔗
constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;
11
#
Returns: (ym.year() + dy) / ym.month().
🔗
constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;
12
#
Returns: ym + dy.
🔗
constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;
13
#
Returns: ym + -dy.
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const year_month& ym);
14
#
Effects: Equivalent to: return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}"), ym.year(), ym.month());
🔗
template<class charT, class traits, class Alloc = allocator<charT>> basic_istream<charT, traits>& from_stream(basic_istream<charT, traits>& is, const charT* fmt, year_month& ym, basic_string<charT, traits, Alloc>* abbrev = nullptr, minutes* offset = nullptr);
15
#
Effects: Attempts to parse the input stream is into the year_­month ym using the format flags given in the NTCTS fmt as specified in [time.parse].
If the parse fails to decode a valid year_­month, is.setstate(ios_­base​::​failbit) is called and ym is not modified.
If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
16
#
Returns: is.

27.8.14 Class year_­month_­day [time.cal.ymd]

27.8.14.1 Overview [time.cal.ymd.overview]

namespace std::chrono { class year_month_day { chrono::year y_; // exposition only chrono::month m_; // exposition only chrono::day d_; // exposition only public: year_month_day() = default; constexpr year_month_day(const chrono::year& y, const chrono::month& m, const chrono::day& d) noexcept; constexpr year_month_day(const year_month_day_last& ymdl) noexcept; constexpr year_month_day(const sys_days& dp) noexcept; constexpr explicit year_month_day(const local_days& dp) noexcept; constexpr year_month_day& operator+=(const months& m) noexcept; constexpr year_month_day& operator-=(const months& m) noexcept; constexpr year_month_day& operator+=(const years& y) noexcept; constexpr year_month_day& operator-=(const years& y) noexcept; constexpr chrono::year year() const noexcept; constexpr chrono::month month() const noexcept; constexpr chrono::day day() const noexcept; constexpr operator sys_days() const noexcept; constexpr explicit operator local_days() const noexcept; constexpr bool ok() const noexcept; }; }
1
#
year_­month_­day represents a specific year, month, and day.
year_­month_­day is a field-based time point with a resolution of days.
[Note 1:
year_­month_­day supports years- and months-oriented arithmetic, but not days-oriented arithmetic.
For the latter, there is a conversion to sys_­days, which efficiently supports days-oriented arithmetic.
— end note]
year_­month_­day meets the Cpp17EqualityComparable (Table 25) and Cpp17LessThanComparable (Table 26) requirements.
2
#
year_­month_­day is a trivially copyable and standard-layout class type.

27.8.14.2 Member functions [time.cal.ymd.members]

🔗
constexpr year_month_day(const chrono::year& y, const chrono::month& m, const chrono::day& d) noexcept;
1
#
Effects: Initializes y_­ with y, m_­ with m, and d_­ with d.
🔗
constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
2
#
Effects: Initializes y_­ with ymdl.year(), m_­ with ymdl.month(), and d_­ with ymdl.day().
[Note 1:
This conversion from year_­month_­day_­last to year_­month_­day might be more efficient than converting a year_­month_­day_­last to a sys_­days, and then converting that sys_­days to a year_­month_­day.
— end note]
🔗
constexpr year_month_day(const sys_days& dp) noexcept;
3
#
Effects: Constructs an object of type year_­month_­day that corresponds to the date represented by dp.
4
#
Remarks: For any value ymd of type year_­month_­day for which ymd.ok() is true, ymd == year_­month_­day{sys_­days{ymd}} is true.
🔗
constexpr explicit year_month_day(const local_days& dp) noexcept;
5
#
Effects: Equivalent to constructing with sys_­days{dp.time_­since_­epoch()}.
🔗
constexpr year_month_day& operator+=(const months& m) noexcept;
6
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
7
#
Effects: *this = *this + m.
8
#
Returns: *this.
🔗
constexpr year_month_day& operator-=(const months& m) noexcept;
9
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
10
#
Effects: *this = *this - m.
11
#
Returns: *this.
🔗
constexpr year_month_day& year_month_day::operator+=(const years& y) noexcept;
12
#
Effects: *this = *this + y.
13
#
Returns: *this.
🔗
constexpr year_month_day& year_month_day::operator-=(const years& y) noexcept;
14
#
Effects: *this = *this - y.
15
#
Returns: *this.
🔗
constexpr chrono::year year() const noexcept;
16
#
Returns: y_­.
🔗
constexpr chrono::month month() const noexcept;
17
#
Returns: m_­.
🔗
constexpr chrono::day day() const noexcept;
18
#
Returns: d_­.
🔗
constexpr operator sys_days() const noexcept;
19
#
Returns: If ok(), returns a sys_­days holding a count of days from the sys_­days epoch to *this (a negative value if *this represents a date prior to the sys_­days epoch).
Otherwise, if y_­.ok() && m_­.ok() is true, returns sys_­days{y_­/m_­/1d} + (d_­ - 1d).
Otherwise the value returned is unspecified.
20
#
Remarks: A sys_­days in the range [days{-12687428}, days{11248737}] which is converted to a year_­month_­day has the same value when converted back to a sys_­days.
21
#
[Example 1: static_assert(year_month_day{sys_days{2017y/January/0}} == 2016y/December/31); static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31); static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1); — end example]
🔗
constexpr explicit operator local_days() const noexcept;
22
#
Returns: local_­days{sys_­days{*this}.time_­since_­epoch()}.
🔗
constexpr bool ok() const noexcept;
23
#
Returns: If y_­.ok() is true, and m_­.ok() is true, and d_­ is in the range [1d, (y_­/m_­/last).day()], then returns true; otherwise returns false.

27.8.14.3 Non-member functions [time.cal.ymd.nonmembers]

🔗
constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
1
#
Returns: x.year() == y.year() && x.month() == y.month() && x.day() == y.day().
🔗
constexpr strong_ordering operator<=>(const year_month_day& x, const year_month_day& y) noexcept;
2
#
Effects: Equivalent to: if (auto c = x.year() <=> y.year(); c != 0) return c; if (auto c = x.month() <=> y.month(); c != 0) return c; return x.day() <=> y.day();
🔗
constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
3
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
4
#
Returns: (ymd.year() / ymd.month() + dm) / ymd.day().
5
#
[Note 1:
If ymd.day() is in the range [1d, 28d], ok() will return true for the resultant year_­month_­day.
— end note]
🔗
constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
6
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
7
#
Returns: ymd + dm.
🔗
constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;
8
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
9
#
Returns: ymd + (-dm).
🔗
constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;
10
#
Returns: (ymd.year() + dy) / ymd.month() / ymd.day().
11
#
[Note 2:
If ymd.month() is February and ymd.day() is not in the range [1d, 28d], ok() can return false for the resultant year_­month_­day.
— end note]
🔗
constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
12
#
Returns: ymd + dy.
🔗
constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;
13
#
Returns: ymd + (-dy).
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const year_month_day& ymd);
14
#
Effects: Equivalent to: return os << (ymd.ok() ? format(STATICALLY-WIDEN<charT>("{:%F}"), ymd) : format(STATICALLY-WIDEN<charT>("{:%F} is not a valid date"), ymd));
🔗
template<class charT, class traits, class Alloc = allocator<charT>> basic_istream<charT, traits>& from_stream(basic_istream<charT, traits>& is, const charT* fmt, year_month_day& ymd, basic_string<charT, traits, Alloc>* abbrev = nullptr, minutes* offset = nullptr);
15
#
Effects: Attempts to parse the input stream is into the year_­month_­day ymd using the format flags given in the NTCTS fmt as specified in [time.parse].
If the parse fails to decode a valid year_­month_­day, is.setstate(ios_­base​::​failbit) is called and ymd is not modified.
If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
16
#
Returns: is.

27.8.15 Class year_­month_­day_­last [time.cal.ymdlast]

27.8.15.1 Overview [time.cal.ymdlast.overview]

namespace std::chrono { class year_month_day_last { chrono::year y_; // exposition only chrono::month_day_last mdl_; // exposition only public: constexpr year_month_day_last(const chrono::year& y, const chrono::month_day_last& mdl) noexcept; constexpr year_month_day_last& operator+=(const months& m) noexcept; constexpr year_month_day_last& operator-=(const months& m) noexcept; constexpr year_month_day_last& operator+=(const years& y) noexcept; constexpr year_month_day_last& operator-=(const years& y) noexcept; constexpr chrono::year year() const noexcept; constexpr chrono::month month() const noexcept; constexpr chrono::month_day_last month_day_last() const noexcept; constexpr chrono::day day() const noexcept; constexpr operator sys_days() const noexcept; constexpr explicit operator local_days() const noexcept; constexpr bool ok() const noexcept; }; }
1
#
year_­month_­day_­last represents the last day of a specific year and month.
year_­month_­day_­last is a field-based time point with a resolution of days, except that it is restricted to pointing to the last day of a year and month.
[Note 1:
year_­month_­day_­last supports years- and months-oriented arithmetic, but not days-oriented arithmetic.
For the latter, there is a conversion to sys_­days, which efficiently supports days-oriented arithmetic.
— end note]
year_­month_­day_­last meets the Cpp17EqualityComparable (Table 25) and Cpp17LessThanComparable (Table 26) requirements.
2
#
year_­month_­day_­last is a trivially copyable and standard-layout class type.

27.8.15.2 Member functions [time.cal.ymdlast.members]

🔗
constexpr year_month_day_last(const chrono::year& y, const chrono::month_day_last& mdl) noexcept;
1
#
Effects: Initializes y_­ with y and mdl_­ with mdl.
🔗
constexpr year_month_day_last& operator+=(const months& m) noexcept;
2
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
3
#
Effects: *this = *this + m.
4
#
Returns: *this.
🔗
constexpr year_month_day_last& operator-=(const months& m) noexcept;
5
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
6
#
Effects: *this = *this - m.
7
#
Returns: *this.
🔗
constexpr year_month_day_last& operator+=(const years& y) noexcept;
8
#
Effects: *this = *this + y.
9
#
Returns: *this.
🔗
constexpr year_month_day_last& operator-=(const years& y) noexcept;
10
#
Effects: *this = *this - y.
11
#
Returns: *this.
🔗
constexpr chrono::year year() const noexcept;
12
#
Returns: y_­.
🔗
constexpr chrono::month month() const noexcept;
13
#
Returns: mdl_­.month().
🔗
constexpr chrono::month_day_last month_day_last() const noexcept;
14
#
Returns: mdl_­.
🔗
constexpr chrono::day day() const noexcept;
15
#
Returns: If ok() is true, returns a day representing the last day of the (year, month) pair represented by *this.
Otherwise, the returned value is unspecified.
16
#
[Note 1:
This value might be computed on demand.
— end note]
🔗
constexpr operator sys_days() const noexcept;
17
#
Returns: sys_­days{year()/month()/day()}.
🔗
constexpr explicit operator local_days() const noexcept;
18
#
Returns: local_­days{sys_­days{*this}.time_­since_­epoch()}.
🔗
constexpr bool ok() const noexcept;
19
#
Returns: y_­.ok() && mdl_­.ok().

27.8.15.3 Non-member functions [time.cal.ymdlast.nonmembers]

🔗
constexpr bool operator==(const year_month_day_last& x, const year_month_day_last& y) noexcept;
1
#
Returns: x.year() == y.year() && x.month_­day_­last() == y.month_­day_­last().
🔗
constexpr strong_ordering operator<=>(const year_month_day_last& x, const year_month_day_last& y) noexcept;
2
#
Effects: Equivalent to: if (auto c = x.year() <=> y.year(); c != 0) return c; return x.month_day_last() <=> y.month_day_last();
🔗
constexpr year_month_day_last operator+(const year_month_day_last& ymdl, const months& dm) noexcept;
3
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
4
#
Returns: (ymdl.year() / ymdl.month() + dm) / last.
🔗
constexpr year_month_day_last operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
5
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
6
#
Returns: ymdl + dm.
🔗
constexpr year_month_day_last operator-(const year_month_day_last& ymdl, const months& dm) noexcept;
7
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
8
#
Returns: ymdl + (-dm).
🔗
constexpr year_month_day_last operator+(const year_month_day_last& ymdl, const years& dy) noexcept;
9
#
Returns: {ymdl.year()+dy, ymdl.month_­day_­last()}.
🔗
constexpr year_month_day_last operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
10
#
Returns: ymdl + dy.
🔗
constexpr year_month_day_last operator-(const year_month_day_last& ymdl, const years& dy) noexcept;
11
#
Returns: ymdl + (-dy).
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const year_month_day_last& ymdl);
12
#
Effects: Equivalent to: return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}"), ymdl.year(), ymdl.month_day_last());

27.8.16 Class year_­month_­weekday [time.cal.ymwd]

27.8.16.1 Overview [time.cal.ymwd.overview]

namespace std::chrono { class year_month_weekday { chrono::year y_; // exposition only chrono::month m_; // exposition only chrono::weekday_indexed wdi_; // exposition only public: year_month_weekday() = default; constexpr year_month_weekday(const chrono::year& y, const chrono::month& m, const chrono::weekday_indexed& wdi) noexcept; constexpr year_month_weekday(const sys_days& dp) noexcept; constexpr explicit year_month_weekday(const local_days& dp) noexcept; constexpr year_month_weekday& operator+=(const months& m) noexcept; constexpr year_month_weekday& operator-=(const months& m) noexcept; constexpr year_month_weekday& operator+=(const years& y) noexcept; constexpr year_month_weekday& operator-=(const years& y) noexcept; constexpr chrono::year year() const noexcept; constexpr chrono::month month() const noexcept; constexpr chrono::weekday weekday() const noexcept; constexpr unsigned index() const noexcept; constexpr chrono::weekday_indexed weekday_indexed() const noexcept; constexpr operator sys_days() const noexcept; constexpr explicit operator local_days() const noexcept; constexpr bool ok() const noexcept; }; }
1
#
year_­month_­weekday represents a specific year, month, and weekday of the month.
year_­month_­weekday is a field-based time point with a resolution of days.
[Note 1:
year_­month_­weekday supports years- and months-oriented arithmetic, but not days-oriented arithmetic.
For the latter, there is a conversion to sys_­days, which efficiently supports days-oriented arithmetic.
— end note]
year_­month_­weekday meets the Cpp17EqualityComparable (Table 25) requirements.
2
#
year_­month_­weekday is a trivially copyable and standard-layout class type.

27.8.16.2 Member functions [time.cal.ymwd.members]

🔗
constexpr year_month_weekday(const chrono::year& y, const chrono::month& m, const chrono::weekday_indexed& wdi) noexcept;
1
#
Effects: Initializes y_­ with y, m_­ with m, and wdi_­ with wdi.
🔗
constexpr year_month_weekday(const sys_days& dp) noexcept;
2
#
Effects: Constructs an object of type year_­month_­weekday which corresponds to the date represented by dp.
3
#
Remarks: For any value ymdl of type year_­month_­weekday for which ymdl.ok() is true, ymdl == year_­month_­weekday{sys_­days{ymdl}} is true.
🔗
constexpr explicit year_month_weekday(const local_days& dp) noexcept;
4
#
Effects: Equivalent to constructing with sys_­days{dp.time_­since_­epoch()}.
🔗
constexpr year_month_weekday& operator+=(const months& m) noexcept;
5
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
6
#
Effects: *this = *this + m.
7
#
Returns: *this.
🔗
constexpr year_month_weekday& operator-=(const months& m) noexcept;
8
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
9
#
Effects: *this = *this - m.
10
#
Returns: *this.
🔗
constexpr year_month_weekday& operator+=(const years& y) noexcept;
11
#
Effects: *this = *this + y.
12
#
Returns: *this.
🔗
constexpr year_month_weekday& operator-=(const years& y) noexcept;
13
#
Effects: *this = *this - y.
14
#
Returns: *this.
🔗
constexpr chrono::year year() const noexcept;
15
#
Returns: y_­.
🔗
constexpr chrono::month month() const noexcept;
16
#
Returns: m_­.
🔗
constexpr chrono::weekday weekday() const noexcept;
17
#
Returns: wdi_­.weekday().
🔗
constexpr unsigned index() const noexcept;
18
#
Returns: wdi_­.index().
🔗
constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
19
#
Returns: wdi_­.
🔗
constexpr operator sys_days() const noexcept;
20
#
Returns: If y_­.ok() && m_­.ok() && wdi_­.weekday().ok(), returns a sys_­days that represents the date (index() - 1) * 7 days after the first weekday() of year()/month().
If index() is 0 the returned sys_­days represents the date 7 days prior to the first weekday() of year()/month().
Otherwise the returned value is unspecified.
🔗
constexpr explicit operator local_days() const noexcept;
21
#
Returns: local_­days{sys_­days{*this}.time_­since_­epoch()}.
🔗
constexpr bool ok() const noexcept;
22
#
Returns: If any of y_­.ok(), m_­.ok(), or wdi_­.ok() is false, returns false.
Otherwise, if *this represents a valid date, returns true.
Otherwise, returns false.

27.8.16.3 Non-member functions [time.cal.ymwd.nonmembers]

🔗
constexpr bool operator==(const year_month_weekday& x, const year_month_weekday& y) noexcept;
1
#
Returns: x.year() == y.year() && x.month() == y.month() && x.weekday_indexed() == y.weekday_indexed()
🔗
constexpr year_month_weekday operator+(const year_month_weekday& ymwd, const months& dm) noexcept;
2
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
3
#
Returns: (ymwd.year() / ymwd.month() + dm) / ymwd.weekday_­indexed().
🔗
constexpr year_month_weekday operator+(const months& dm, const year_month_weekday& ymwd) noexcept;
4
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
5
#
Returns: ymwd + dm.
🔗
constexpr year_month_weekday operator-(const year_month_weekday& ymwd, const months& dm) noexcept;
6
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
7
#
Returns: ymwd + (-dm).
🔗
constexpr year_month_weekday operator+(const year_month_weekday& ymwd, const years& dy) noexcept;
8
#
Returns: {ymwd.year()+dy, ymwd.month(), ymwd.weekday_­indexed()}.
🔗
constexpr year_month_weekday operator+(const years& dy, const year_month_weekday& ymwd) noexcept;
9
#
Returns: ymwd + dy.
🔗
constexpr year_month_weekday operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
10
#
Returns: ymwd + (-dy).
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const year_month_weekday& ymwd);
11
#
Effects: Equivalent to: return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}/{}"), ymwd.year(), ymwd.month(), ymwd.weekday_indexed());

27.8.17 Class year_­month_­weekday_­last [time.cal.ymwdlast]

27.8.17.1 Overview [time.cal.ymwdlast.overview]

namespace std::chrono { class year_month_weekday_last { chrono::year y_; // exposition only chrono::month m_; // exposition only chrono::weekday_last wdl_; // exposition only public: constexpr year_month_weekday_last(const chrono::year& y, const chrono::month& m, const chrono::weekday_last& wdl) noexcept; constexpr year_month_weekday_last& operator+=(const months& m) noexcept; constexpr year_month_weekday_last& operator-=(const months& m) noexcept; constexpr year_month_weekday_last& operator+=(const years& y) noexcept; constexpr year_month_weekday_last& operator-=(const years& y) noexcept; constexpr chrono::year year() const noexcept; constexpr chrono::month month() const noexcept; constexpr chrono::weekday weekday() const noexcept; constexpr chrono::weekday_last weekday_last() const noexcept; constexpr operator sys_days() const noexcept; constexpr explicit operator local_days() const noexcept; constexpr bool ok() const noexcept; }; }
1
#
year_­month_­weekday_­last represents a specific year, month, and last weekday of the month.
year_­month_­weekday_­last is a field-based time point with a resolution of days, except that it is restricted to pointing to the last weekday of a year and month.
[Note 1:
year_­month_­weekday_­last supports years- and months-oriented arithmetic, but not days-oriented arithmetic.
For the latter, there is a conversion to sys_­days, which efficiently supports days-oriented arithmetic.
— end note]
year_­month_­weekday_­last meets the Cpp17EqualityComparable (Table 25) requirements.
2
#
year_­month_­weekday_­last is a trivially copyable and standard-layout class type.

27.8.17.2 Member functions [time.cal.ymwdlast.members]

🔗
constexpr year_month_weekday_last(const chrono::year& y, const chrono::month& m, const chrono::weekday_last& wdl) noexcept;
1
#
Effects: Initializes y_­ with y, m_­ with m, and wdl_­ with wdl.
🔗
constexpr year_month_weekday_last& operator+=(const months& m) noexcept;
2
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
3
#
Effects: *this = *this + m.
4
#
Returns: *this.
🔗
constexpr year_month_weekday_last& operator-=(const months& m) noexcept;
5
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
6
#
Effects: *this = *this - m.
7
#
Returns: *this.
🔗
constexpr year_month_weekday_last& operator+=(const years& y) noexcept;
8
#
Effects: *this = *this + y.
9
#
Returns: *this.
🔗
constexpr year_month_weekday_last& operator-=(const years& y) noexcept;
10
#
Effects: *this = *this - y.
11
#
Returns: *this.
🔗
constexpr chrono::year year() const noexcept;
12
#
Returns: y_­.
🔗
constexpr chrono::month month() const noexcept;
13
#
Returns: m_­.
🔗
constexpr chrono::weekday weekday() const noexcept;
14
#
Returns: wdl_­.weekday().
🔗
constexpr chrono::weekday_last weekday_last() const noexcept;
15
#
Returns: wdl_­.
🔗
constexpr operator sys_days() const noexcept;
16
#
Returns: If ok() == true, returns a sys_­days that represents the last weekday() of year()/month().
Otherwise the returned value is unspecified.
🔗
constexpr explicit operator local_days() const noexcept;
17
#
Returns: local_­days{sys_­days{*this}.time_­since_­epoch()}.
🔗
constexpr bool ok() const noexcept;
18
#
Returns: y_­.ok() && m_­.ok() && wdl_­.ok().

27.8.17.3 Non-member functions [time.cal.ymwdlast.nonmembers]

🔗
constexpr bool operator==(const year_month_weekday_last& x, const year_month_weekday_last& y) noexcept;
1
#
Returns: x.year() == y.year() && x.month() == y.month() && x.weekday_last() == y.weekday_last()
🔗
constexpr year_month_weekday_last operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
2
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
3
#
Returns: (ymwdl.year() / ymwdl.month() + dm) / ymwdl.weekday_­last().
🔗
constexpr year_month_weekday_last operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept;
4
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
5
#
Returns: ymwdl + dm.
🔗
constexpr year_month_weekday_last operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
6
#
Constraints: If the argument supplied by the caller for the months parameter is convertible to years, its implicit conversion sequence to years is worse than its implicit conversion sequence to months ([over.ics.rank]).
7
#
Returns: ymwdl + (-dm).
🔗
constexpr year_month_weekday_last operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
8
#
Returns: {ymwdl.year()+dy, ymwdl.month(), ymwdl.weekday_­last()}.
🔗
constexpr year_month_weekday_last operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept;
9
#
Returns: ymwdl + dy.
🔗
constexpr year_month_weekday_last operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
10
#
Returns: ymwdl + (-dy).
🔗
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const year_month_weekday_last& ymwdl);
11
#
Effects: Equivalent to: return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}/{}"), ymwdl.year(), ymwdl.month(), ymwdl.weekday_last());

27.8.18 Conventional syntax operators [time.cal.operators]

1
#
A set of overloaded operator/ functions provides a conventional syntax for the creation of civil calendar dates.
2
#
[Note 1:
The year, month, and day are accepted in any of the following 3 orders: year/month/day month/day/year day/month/year
Anywhere a day is required, any of the following can also be specified: last weekday[i] weekday[last]
— end note]
3
#
[Note 2:
Partial-date types such as year_­month and month_­day can be created by not applying the second division operator for any of the three orders.
For example: year_month ym = 2015y/April; month_day md1 = April/4; month_day md2 = 4d/April;
— end note]
4
#
[Example 1: auto a = 2015/4/4; // a == int(125) auto b = 2015y/4/4; // b == year_­month_­day{year(2015), month(4), day(4)} auto c = 2015y/4d/April; // error: no viable operator/ for first / auto d = 2015/April/4; // error: no viable operator/ for first / — end example]
🔗
constexpr year_month operator/(const year& y, const month& m) noexcept;
5
#
Returns: {y, m}.
🔗
constexpr year_month operator/(const year& y, int m) noexcept;
6
#
Returns: y / month(m).
🔗
constexpr month_day operator/(const month& m, const day& d) noexcept;
7
#
Returns: {m, d}.
🔗
constexpr month_day operator/(const month& m, int d) noexcept;
8
#
Returns: m / day(d).
🔗
constexpr month_day operator/(int m, const day& d) noexcept;
9
#
Returns: month(m) / d.
🔗
constexpr month_day operator/(const day& d, const month& m) noexcept;
10
#
Returns: m / d.
🔗
constexpr month_day operator/(const day& d, int m) noexcept;
11
#
Returns: month(m) / d.
🔗
constexpr month_day_last operator/(const month& m, last_spec) noexcept;
12
#
Returns: month_­day_­last{m}.
🔗
constexpr month_day_last operator/(int m, last_spec) noexcept;
13
#
Returns: month(m) / last.
🔗
constexpr month_day_last operator/(last_spec, const month& m) noexcept;
14
#
Returns: m / last.
🔗
constexpr month_day_last operator/(last_spec, int m) noexcept;
15
#
Returns: month(m) / last.
🔗
constexpr month_weekday operator/(const month& m, const weekday_indexed& wdi) noexcept;
16
#
Returns: {m, wdi}.
🔗
constexpr month_weekday operator/(int m, const weekday_indexed& wdi) noexcept;
17
#
Returns: month(m) / wdi.
🔗
constexpr month_weekday operator/(const weekday_indexed& wdi, const month& m) noexcept;
18
#
Returns: m / wdi.
🔗
constexpr month_weekday operator/(const weekday_indexed& wdi, int m) noexcept;
19
#
Returns: month(m) / wdi.
🔗
constexpr month_weekday_last operator/(const month& m, const weekday_last& wdl) noexcept;
20
#
Returns: {m, wdl}.
🔗
constexpr month_weekday_last operator/(int m, const weekday_last& wdl) noexcept;
21
#
Returns: month(m) / wdl.
🔗
constexpr month_weekday_last operator/(const weekday_last& wdl, const month& m) noexcept;
22
#
Returns: m / wdl.
🔗
constexpr month_weekday_last operator/(const weekday_last& wdl, int m) noexcept;
23
#
Returns: month(m) / wdl.
🔗
constexpr year_month_day operator/(const year_month& ym, const day& d) noexcept;
24
#
Returns: {ym.year(), ym.month(), d}.
🔗
constexpr year_month_day operator/(const year_month& ym, int d) noexcept;
25
#
Returns: ym / day(d).
🔗
constexpr year_month_day operator/(const year& y, const month_day& md) noexcept;
26
#
Returns: y / md.month() / md.day().
🔗
constexpr year_month_day operator/(int y, const month_day& md) noexcept;
27
#
Returns: year(y) / md.
🔗
constexpr year_month_day operator/(const month_day& md, const year& y) noexcept;
28
#
Returns: y / md.
🔗
constexpr year_month_day operator/(const month_day& md, int y) noexcept;
29
#
Returns: year(y) / md.
🔗
constexpr year_month_day_last operator/(const year_month& ym, last_spec) noexcept;
30
#
Returns: {ym.year(), month_­day_­last{ym.month()}}.
🔗
constexpr year_month_day_last operator/(const year& y, const month_day_last& mdl) noexcept;
31
#
Returns: {y, mdl}.
🔗
constexpr year_month_day_last operator/(int y, const month_day_last& mdl) noexcept;
32
#
Returns: year(y) / mdl.
🔗
constexpr year_month_day_last operator/(const month_day_last& mdl, const year& y) noexcept;
33
#
Returns: y / mdl.
🔗
constexpr year_month_day_last operator/(const month_day_last& mdl, int y) noexcept;
34
#
Returns: year(y) / mdl.
🔗
constexpr year_month_weekday operator/(const year_month& ym, const weekday_indexed& wdi) noexcept;
35
#
Returns: {ym.year(), ym.month(), wdi}.
🔗
constexpr year_month_weekday operator/(const year& y, const month_weekday& mwd) noexcept;
36
#
Returns: {y, mwd.month(), mwd.weekday_­indexed()}.
🔗
constexpr year_month_weekday operator/(int y, const month_weekday& mwd) noexcept;
37
#
Returns: year(y) / mwd.
🔗
constexpr year_month_weekday operator/(const month_weekday& mwd, const year& y) noexcept;
38
#
Returns: y / mwd.
🔗
constexpr year_month_weekday operator/(const month_weekday& mwd, int y) noexcept;
39
#
Returns: year(y) / mwd.
🔗
constexpr year_month_weekday_last operator/(const year_month& ym, const weekday_last& wdl) noexcept;
40
#
Returns: {ym.year(), ym.month(), wdl}.
🔗
constexpr year_month_weekday_last operator/(const year& y, const month_weekday_last& mwdl) noexcept;
41
#
Returns: {y, mwdl.month(), mwdl.weekday_­last()}.
🔗
constexpr year_month_weekday_last operator/(int y, const month_weekday_last& mwdl) noexcept;
42
#
Returns: year(y) / mwdl.
🔗
constexpr year_month_weekday_last operator/(const month_weekday_last& mwdl, const year& y) noexcept;
43
#
Returns: y / mwdl.
🔗
constexpr year_month_weekday_last operator/(const month_weekday_last& mwdl, int y) noexcept;
44
#
Returns: year(y) / mwdl.