27 Time library [time]

27.8 The civil calendar [time.cal]

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)}.