`<chrono>`, operatory

Artykuł
10/12/2023

`operator+`

Operator dodawania dla następujących typów:

1) 
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
   operator+(
      const duration<Rep1, Period1>& Left,
      const duration<Rep2, Period2>& Right);

2)
template <class Clock, class Duration1, class Rep2, class Period2>
constexpr time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
   operator+(
      const time_point<Clock, Duration1>& Time,
      const duration<Rep2, Period2>& Dur);

3)
template <class Rep1, class Period1, class Clock, class Duration2>
time_point<Clock, constexpr typename common_type<duration<Rep1, Period1>, Duration2>::type>
   operator+(
      const duration<Rep1, Period1>& Dur,
      const time_point<Clock, Duration2>& Time);

4)
constexpr day operator+(const day& d, const days& ds) noexcept; // C++20
constexpr day operator+(const days& ds, const day&  d) noexcept; // C++20

5)
constexpr month operator+(const month& m, const months& ms) noexcept; // C++20
constexpr month operator+(const months& ms, const month& m) noexcept; // C++20

6)
constexpr weekday operator+(const weekday& wd, const days& wds) noexcept // C++20
constexpr weekday operator+(const days& ds, const weekday& wd) noexcept; // C++20

7)
constexpr year operator+(const year& y, const years& ys) noexcept; // C++20
constexpr year operator+(const years& ys, const year& y) noexcept; // C++20

8)
constexpr year_month operator+(const year_month& ym, const months& dm) noexcept; // C++20
constexpr year_month operator+(const months& dm, const year_month& ym) noexcept; // C++20
constexpr year_month operator+(const year_month& ym, const years& dy) noexcept; // C++20
constexpr year_month operator+(const years& dy, const year_month& ym) noexcept; // C++20

9)
constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept; // C++20
constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept; // C++20
constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept; // C++20
constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept; // C++20

10)
constexpr year_month_day_last operator+(const year_month_day_last& ymdl, const months& dm) noexcept; // C++20

11)
constexpr year_month_day_last operator+(const months& dm, const year_month_day_last& ymdl) noexcept; // C++20

12)
constexpr year_month_day_last operator+(const year_month_day_last& ymdl, const years& dy) noexcept; // C++20
constexpr year_month_day_last operator+(const years& dy, const year_month_day_last& ymdl) noexcept; // C++20

13)
constexpr year_month_weekday operator+(const year_month_weekday& ymwd, const months& dm) noexcept; // C++20
constexpr year_month_weekday operator+(const months& dm, const year_month_weekday& ymwd) noexcept; // C++20

14)
constexpr year_month_weekday operator+(const year_month_weekday& ymwd, const years& dy) noexcept; // C++20

15)
constexpr year_month_weekday operator+(const years& dy, const year_month_weekday& ymwd) noexcept; // C++20

16)
constexpr year_month_weekday_last operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept; // C++20
constexpr year_month_weekday_last operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept; // C++20

17)
constexpr year_month_weekday_last operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept; // C++20
constexpr year_month_weekday_last operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept; // C++20

Wartość zwracana

1) Po przekonwertowaniu Left i Right na wspólny typ zwraca duration wartość z liczbą znaczników równą sumie przekonwertowanych liczników znaczników.

2–3) Zwróć time_point obiekt reprezentujący punkt w czasie, który jest przesiedlony przez interwał Dur od punktu w czasie Time.

4) Zwraca wynik .d+ds.count() Jeśli wynik jest poza zakresem [0, 255], wynik jest nieokreślony.

5) Zwraca wynik .m+ms.count() Jeśli wynik jest poza zakresem [1, 12], jest zmniejszony modulo 12, a następnie +1.

6) Zwraca wynik dodawania liczby dni i dni roboczych do elementu weekday. Wynik będzie modulo 7, więc zawsze w zakresie [0,6]

7) Zwraca wynik dodania roku do określonej liczby lat.

8) Zwraca wynik dodawania liczby miesięcy i lat do określonego miesiąca i roku.

9) Zwraca wynik dodawania miesięcy lub lat do elementu year_month_day. Jeśli ymd.month() wartość jest February i ymd.day() nie znajduje się w zakresie [1d, 28d], ok() może zwrócić false wynik dodania.

10) Zwraca wartość (ymdl.year() / ymdl.month() + dm) / last. Uwaga: / Używany tutaj nie jest operatorem dzielenia. Jest to operator daty.

11) Zwraca wartość ymdl + dm.

12) Zwraca {ymdl.year()+dy, ymdl.month_day_last()}

13) Zwraca wartość ymwd + dm.count().

14–15) Zwraca wartość {ymwd.year()+dy, ymwd.month(), ymwd.weekday_indexed()}.

16) Zwraca wartość (ymwdl.year() / ymwdl.month() + dm) / ymwdl.weekday_last(). Uwaga: / Używany tutaj nie jest operatorem dzielenia, ale operatorem daty.

17) Zwraca: ymwdl + dy

Przykład: `operator+`

// compile using: /std:c++latest
#include <iostream>
#include <chrono>

using namespace std::chrono;

int main()
{
    // day
    day d{1};
    std::cout << d + days(2) << '\n'; // 03

    // month
    month m{11};
    std::cout << m + months(3)<< '\n'; // Feb

    // weekday
    weekday wd = Thursday;
    std::cout << wd + days(1) << '\n'; // Fri

    // year_month_day_last
    year_month_day_last ymdl{June / last / 2021};
    std::cout << ymdl + years{1} + months{1} << '\n'; // 2022/Jul/last

    // year_month_weekday
    year_month_weekday ymw{ year(1997) / January / Wednesday[1] };
    std::cout << ymw + months{1} << '\n'; // 1997/Feb/Wed[1]
    std::cout << ymw + years{1} << '\n'; // 1998/Jan/Wed[1] 

    // year_month_weekday_last
    year_month_weekday_last ymwl{ year(1997) / January / Wednesday[last] };
    std::cout << ymwl + months{ 1 } << '\n'; // 1997/Feb/Wed[last]
    std::cout << ymwl + years{ 1 } << '\n'; // 1998/Jan/Wed[last] 

    return 0;
}

03
Feb
Fri
2022/Jul/last
1997/Feb/Wed[1]
1998/Jan/Wed[1]
1997/Feb/Wed[last]
1998/Jan/Wed[last]

Jednoargumentowy `operator+`

Zastosuj jednoargumentowy plus do następujących typów:

duration.

// duration
constexpr common_type_t<duration> operator+() const // C++20

Wartość zwracana

Zwraca *this

`operator-`

Operator odejmowania dla następujących typów:

1)
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
   operator-(
       const duration<Rep1, Period1>& Left,
       const duration<Rep2, Period2>& Right);
2)
template <class Clock, class Duration1, class Rep2, class Period2>
constexpr time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type
   operator-(
       const time_point<Clock, Duration1>& Time,
       const duration<Rep2, Period2>& Dur);
3)
template <class Clock, class Duration1, class Duration2>
constexpr typename common_type<Duration1, Duration2>::type
   operator-(
       const time_point<Clock, Duration1>& Left,
       const time_point<Clock, Duration2>& Right);
4)
constexpr day operator-(const day& d,  days& ds) noexcept; // C++20
constexpr day operator-(const day& d, const day& d) noexcept; // C++20

5)
constexpr month operator-(const month& m, const months& ms) noexcept; // C++20
constexpr month operator-(const month& m, const month& ms) noexcept; // C++20

6)
constexpr months operator-(const year_month& Left, const year_month& Right) noexcept; // C++20

7)
constexpr weekday operator-(const weekday& Left, const days& Right) noexcept; // C++20

8)
constexpr days operator-(const weekday& Left, const weekday& Right) noexcept; // C++20

9)
constexpr year operator-(const year& y, const years& ys) noexcept; // C++20

10)
constexpr years operator-(const year& y, const year& y2) noexcept; // C++20

11)
constexpr year_month operator-(const year_month& ym, const months& dm) noexcept; // C++20
constexpr year_month operator-(const year_month& ym, const years& dy) noexcept; // C++20

12)
constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept; // C++20
constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept; // C++20

13)
constexpr year_month_day_last operator-(const year_month_day_last& ymdl, const months& dm) noexcept;  // C++20

14)
constexpr year_month_day_last operator-(const year_month_day_last& ymdl, const years& dy) noexcept;  // C++20

15)
constexpr year_month_weekday operator-(const year_month_weekday& ymwd, const months& dm) noexcept; // C++20

16)
constexpr year_month_weekday operator-(const year_month_weekday& ymwd, const years& dy) noexcept; // C++20

17)
constexpr year_month_weekday_last operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept; // C++20

18)
constexpr year_month_weekday_last operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept; // C++20

Wartość zwracana

1) Po przekonwertowaniu czasu trwania odjętego do ich wspólnego typu zwraca duration wartość z liczbą znaczników równą liczbie kleszczy Right odejmowanych od liczby kleszczy w .Left

2) Zwraca wartość time_point reprezentującą punkt w czasie, który jest wypierany przez negację interwału czasu reprezentowanego przez Durelement , z punktu w czasie określonego przez Time.

3) Zwraca duration obiekt reprezentujący przedział czasu między Left i Right.

4) Zwraca wynik .d-ds.count() Jeśli wynik jest poza zakresem [0, 255], wynik jest nieokreślony.

5) Jeśli m.ok() == true i ms.ok() == true, zwraca wynik odejmowania dwóch wartości miesiąca lub odejmowania liczby miesięcy. Wynik będzie mieścił się w zakresie [1, 12]. Jeśli wynik jest ujemny, owija się wokół. Na przykład odejmowanie jednego miesiąca od stycznia (month m1{1} - months{1}; powoduje 12 (grudzień).

6) Zwraca różnicę między miesiącami Left i Right

7) Jeśli Left.ok() == true i Right.ok() == true, zwraca wartość weekday w zakresie [days{0}, days{6}].

8) Zwraca liczbę dni między dwoma dniami tygodnia.

9) Zwraca year(int(y)-ys.count)())

10) Zwraca wartość years(int(y) - int(y2)). Odejmowanie dwóch year wartości powoduje zwrócenie wartości , która reprezentuje różnicę std::chrono::yearsmiędzy latami y i y2. Na przykład 2021y-2000y tworzy wartość years(21).

11) Zwraca wynik odejmowania miesięcy lub lat od year_month wartości.

12) Zwraca wynik odejmowania year_month_day miesięcy od wartości.

13) Zwraca wynik odejmowania liczby miesięcy od year_month_day_last wartości. Zasadniczo: ymdl-dm.

14) Zwraca wynik odejmowania liczby lat od year_month_day_last wartości. Zasadniczo: ymdl-dy.

15) Zwraca wynik odejmowania liczby miesięcy od year_month_weekday wartości. Zasadniczo: ymwd-dm.

16) Zwraca wynik odejmowania liczby lat od year_month_weekday wartości. Zasadniczo: ymwd-dy.

17) Zwraca wynik odejmowania liczby miesięcy od year_month_weekday_last wartości. Zasadniczo: ymwdl-dm.

18) Zwraca wynik odejmowania liczby lat od year_month_weekday_last wartości. Zasadniczo: ymwdl-dy.

Przykład: `operator-`

// compile using: /std:c++latest
#include <iostream>
#include <chrono>

using namespace std::chrono;

int main()
{
    // day
    day d{10};
    d = d - days(5);  
    std::cout << d << '\n'; // 05

    // month 
    month m{2};
    m = m - months{1};
    std::cout << m << '\n'; // Jan
    m = m - months{1};
    std::cout << m << '\n'; // Dec

    // year
    auto diff1 = 2021y-2000y;
    auto diff2 = 2021y-years{1};
    std::cout << diff1.count() << '\n'; // 21
    std::cout << diff2 << '\n'; // 2020

    // year_month
    const year theYear{ 2021 };
    year_month ym1{theYear, June};
    year_month ym2 = ym1 - months{2};
    std::cout << ym2 << '\n'; // 2021/Apr
    year_month ym3 = ym1 - years{2};
    std::cout << ym3 << '\n'; // 2019/Jun

    // year_month_day_last
    year_month_day_last ymdl = June / last / 2021;
    std::cout << ymdl - years{1} - months{1} << '\n'; // 2022/Jul/last

    // year_month_weekday
    year_month_weekday ymw{ year(1997) / January / Wednesday[1] };
    std::cout << ymw - months{1} << '\n'; // 1996/Dec/Wed[1]
    std::cout << ymw - years{1} << '\n'; // 1996/Jan/Wed[1] 

    // year_month_weekday_last
    year_month_weekday_last ymwl{ year(1997) / January / Wednesday[last] };
    std::cout << ymwl - months{ 1 } << '\n'; // 1996/Dec/Wed[last]
    std::cout << ymwl - years{ 1 } << '\n'; // 1996/Jan/Wed[last]
    
    return 0;
}

05
Jan
Dec
21
2020
2021/Apr
2019/Jun
2020/May/last
1996/Dec/Wed[1]
1996/Jan/Wed[1]
1996/Dec/Wed[last]
1996/Jan/Wed[last]

Jednoargumentowy `operator-`

Neguje element duration.

constexpr common_type_t<duration> operator-() const;

Wartość zwracana

Zwraca negowaną kopię *this

Przykład: jednoargumentowy `operator-`

// compile using: /std:c++latest
#include <iostream>
#include <chrono>

using namespace std::chrono;

int main()
{
   duration<int, std::milli> milliseconds(120);
   std::cout << -milliseconds << '\n';
   return 0;
}

-120ms

`operator!=`

Określa, czy:

1) Dwa duration obiekty nie reprezentują tej samej liczby kleszczy.
2) Dwa time_point obiekty nie reprezentują tego samego punktu w czasie.

1)
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator!=(
    const duration<Rep1, Period1>& Left,
    const duration<Rep2, Period2>& Right);

2)
template <class Clock, class Duration1, class Duration2>
constexpr bool operator!=(
    const time_point<Clock, Duration1>& Left,
    const time_point<Clock, Duration2>& Right);

Parametry

Left
Lewy duration lub time_point obiekt.

Right
Prawo duration lub time_point obiekt.

Wartość zwracana

1) Zwraca true , jeśli liczba znaczników typu wspólnego do Left i Right nie jest równa. W przeciwnym razie zwraca wartość false.
2) Zwraca, true jeśli dwa time_point obiekty nie reprezentują tego samego punktu w czasie. W przeciwnym razie zwraca wartość false.

`operator*`

Operator mnożenia obiektów duration . Po przekonwertowaniu s mnożonego durationna typ wspólny zwraca wartość duration z liczbą znaczników równą mnożenie przekonwertowanych liczb znaczników.

1)
template <class Rep1, class Period1, class Rep2>
constexpr duration<typename common_type<Rep1, Rep2>::type, Period1>
   operator*(
      const duration<Rep1, Period1>& Dur,
      const Rep2& Mult);

2)
template <class Rep1, class Rep2, class Period2>
constexpr duration<typename common_type<Rep1, Rep2>::type, Period2>
   operator*(
       const Rep1& Mult,
       const duration<Rep2,
       Period2>& Dur);

Parametry

Dur
Obiekt duration.

Mult
Wartość całkowita.

Wartość zwracana

duration Zwraca obiekt, którego długość interwału jest Mult mnożona przez długość Durobiektu .

1) Jeśli nie is_convertible<Rep2, common_type<Rep1, Rep2>>zostanie ona przechowywana true, ta funkcja nie uczestniczy w rozwiązywaniu przeciążenia. Aby uzyskać więcej informacji, zobacz <type_traits>.

2) O ile nie is_convertible<Rep1, common_type<Rep1, Rep2>>zostanie ona przechowywana true, ta funkcja nie uczestniczy w rozwiązywaniu przeciążenia. Aby uzyskać więcej informacji, zobacz <type_traits>.

`operator<`

1) Po przekonwertowaniu durations porównywanych ze wspólnym typem określa, czy liczba kleszczy dla Left parametru jest mniejsza niż dla Right.

2) Określa, czy punkt w czasie od epoki Lefttime_point jest krótszy niż czas od epoki time_point w .Right

1)
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator<(
    const duration<Rep1, Period1>& Left,
    const duration<Rep2, Period2>& Right);

2)
template <class Clock, class Duration1, class Duration2>
constexpr bool operator<(
    const time_point<Clock, Duration1>& Left,
    const time_point<Clock, Duration2>& Right);

Parametry

Left
Lewy duration lub time_point obiekt.

Right
Prawo duration lub time_point obiekt.

Wartość zwracana

1) Zwraca true , jeśli liczba znaczników dla Left jest mniejsza niż liczba kleszczy dla Right. W przeciwnym razie funkcja zwraca falsewartość .

2) Zwraca wartość true , jeśli Left poprzedza Rightwartość . W przeciwnym razie zwraca wartość false.

`operator<=`

1) Po przekonwertowaniu durations porównywanych ze wspólnym typem określa, czy liczba kleszczy dla Left jest mniejsza lub taka sama jak Right.

2) Określa, czy punkt w czasie od epoki Lefttime_point jest mniejszy niż lub równy czasowi od epoki time_point w .Right

1)
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator<=(
    const duration<Rep1, Period1>& Left,
    const duration<Rep2, Period2>& Right);

2)
template <class Clock, class Duration1, class Duration2>
constexpr bool operator<=(
    const time_point<Clock, Duration1>& Left,
    const time_point<Clock, Duration2>& Right);

Parametry

Left
Lewy duration lub time_point obiekt.

Right
Prawo duration lub time_point obiekt.

Wartość zwracana

1) Zwraca true , jeśli liczba znaczników dla Left jest mniejsza lub równa liczbie kleszczy dla Right. W przeciwnym razie funkcja zwraca falsewartość .

2) Zwraca wartość true , jeśli Left poprzedza wartość lub jest równa Right. W przeciwnym razie zwraca wartość false.

`operator==`

Określa, czy:

1) duration obiekty reprezentują interwały czasu, które mają taką samą długość.
2) time_point obiekty reprezentują ten sam punkt w czasie.
3) day obiekty reprezentują ten sam dzień.
4) month obiekty reprezentują ten sam miesiąc.
5) month_day obiekty reprezentują ten sam miesiąc i dzień.
6) month_day_last obiekty reprezentują ten sam miesiąc.
7) month_weekday obiekty reprezentują ten sam miesiąc i nth dni powszednie.
8) month_weekday_last obiekty reprezentują ten sam miesiąc i ostatni dzień tygodnia.
9) weekday obiekty reprezentują ten sam dzień powszedni.
10) weekday_last obiekty reprezentują ten sam ostatni dzień tygodnia miesiąca.
11) weekday_indexed reprezentują ten sam indeks dnia tygodnia.
12) year reprezentują ten sam rok.
13) year_month reprezentują ten sam rok i miesiąc.
14) year_month_day reprezentują ten sam rok, miesiąc i dzień.
15) year_month_day_last reprezentują ten sam ostatni dzień roku i miesiąca.
16) year_month_weekday reprezentują ten sam dzień tygodnia, rok i miesiąc.
17) year_month_weekday_last reprezentują ten sam ostatni dzień tygodnia miesiąca, roku i miesiąca.
18) time_zone_link mają ten sam nameelement . Nazwa nie jest brana target pod uwagę.
19) zoned_time reprezentują ten sam czas i strefę czasową.

// 1) duration<Rep, Period>
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator==(
    const duration<Rep1, Period1>& Left,
    const duration<Rep2, Period2>& Right);

// 2) time_point
template <class Clock, class Duration1, class Duration2>
constexpr bool operator==(
    const time_point<Clock, Duration1>& Left,
    const time_point<Clock, Duration2>& Right);

// 3) day
constexpr bool operator==(const day& Left, const day& Right) noexcept; // C++20

// 4) month
constexpr bool operator==(const month& Left, const month& Right) noexcept; // C++20

// 5) month_day
constexpr bool operator==(const month_day& Left, const month_day& Right) noexcept; // C++20

// 6) month_day_last
constexpr bool operator==(const month_day_last& Left, const month_day_last& Right) noexcept; // C++20

// 7) month_weekday
constexpr bool operator==(const month_weekday& Left, const month_weekday& Right) noexcept; // C++20

// 8) month_weekday_last
constexpr bool operator==(const month_weekday_last& Left, const month_weekday_last& Right) noexcept; // C++20

// 9) weekday
constexpr bool operator==(const weekday& Left, const weekday& Right) noexcept; // C++20

// 10) weekday_last
constexpr bool operator==(const weekday_last& Left, const weekday_last& Right) noexcept; // C++20

// 11) weekday_indexed
constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept; // C++20

// 12) year
constexpr bool operator==(const year& Left, const year& y ) noexcept; // C++20

// 13) year_month
constexpr bool operator==(const year_month& Left, const year_month& Right) noexcept; // C++20

// 14) year_month_day
constexpr bool operator==(const year_month_day& Left, const year_month_day& Right) noexcept; // C++20

// 15) year_month_day_last
constexpr bool operator==(const year_month_day_last& Left, const year_month_day_last& Right) noexcept; // C++20

// 16) year_month_weekday
constexpr bool operator==(const year_month_weekday& Left, const year_month_weekday& Right) noexcept; // C++20

// 17)  year_month_weekday_last
constexpr bool operator==(const year_month_weekday_last& Left, const year_month_weekday_last& Right) noexcept; // C++20

// 18) time_zone_link
bool operator==(const time_zone_link& Left, const time_zone_link& Right) noexcept; // C++20

// 19) zoned_time
template <class Duration1, class Duration2, class TimeZonePtr>
bool operator==(const zoned_time<Duration1, TimeZonePtr>& Left, const zoned_time<Duration2, TimeZonePtr>& Right); // C++20

Parametry

Left
Obiekt po lewej stronie do porównania, na przykład Left == Right

Right
Odpowiedni obiekt do porównania.

Wartość zwracana

1) Zwraca true wartość, jeśli liczba znaczników typu wspólnego do Left i Right jest równa. W przeciwnym razie zwraca wartość false.
2) Zwraca wartość true if Left i Right reprezentuje ten sam punkt w czasie. W przeciwnym razie zwraca wartość false.
3–17) Zwraca true wartość if Left i Right ma tę samą wartość. W przeciwnym razie zwraca wartość false.
18) Zwraca wartość true , jeśli Left.name() == Right.name(). W przeciwnym razie zwraca wartość *false*.
19) Zwraca wartość true , jeśli Left.get_time_zone() == _Right.get_time_zone() && Left.get_sys_time() == Right.get_sys_time();

`operator>`

1) Po przekonwertowaniu durations porównywanych ze wspólnym typem określa, czy liczba kleszczy dla Left parametru jest większa niż dla Right.

2) Określa, czy punkt w czasie od epoki Lefttime_point jest większy niż czas od epoki time_point w .Right

1) 
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator>(
    const duration<Rep1, Period1>& Left,
    const duration<Rep2, Period2>& Right);

2)
template <class Clock, class Duration1, class Duration2>
constexpr bool operator>(
    const time_point<Clock, Duration1>& Left,
    const time_point<Clock, Duration2>& Right);

Parametry

Left
Lewy duration lub time_point obiekt.

Right
Prawo duration lub time_point obiekt.

Wartość zwracana

1) Zwraca true , jeśli liczba kleszczy dla Left jest większa niż liczba kleszczy dla Right. W przeciwnym razie funkcja zwraca falsewartość .

2) Zwraca wartość true , jeśli Left nastąpi po .Right W przeciwnym razie zwraca wartość false.

`operator>=`

1) Po przekonwertowaniu durations porównywanych ze wspólnym typem określa, czy liczba kleszczy dla Left elementu jest większa lub równa Right.

2) Określa, czy punkt w czasie od epoki Lefttime_point jest większy niż lub równy czasowi od epoki time_point w .Right

1)
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator>=(
    const duration<Rep1, Period1>& Left,
    const duration<Rep2, Period2>& Right);

2)
template <class Clock, class Duration1, class Duration2>
constexpr bool operator>=(
    const time_point<Clock, Duration1>& Left,
    const time_point<Clock, Duration2>& Right);

Parametry

Left
Lewy duration lub time_point obiekt.

Right
Prawo duration lub time_point obiekt.

Wartość zwracana

1) Zwraca true , jeśli liczba kleszczy dla Left jest większa lub równa liczbie kleszczy dla Right. W przeciwnym razie funkcja zwraca falsewartość .

2) Zwraca wartość true , jeśli Left występuje po , lub jest równa , Right. W przeciwnym razie zwraca wartość false.

`operator<=>`

Operator statku kosmicznego z operatorami operator==, syntetyzuje operatory dla <, <=, >, >=i != dla następujących typów:

1)
constexpr bool operator<=>(const day& Left, const day& Right) noexcept; // C++20

constexpr std::strong_ordering operator<=>(const month& Left, const month& Right) noexcept; // C++20

constexpr strong_ordering operator<=>(const month_day& Left, const month_day& Right) noexcept; // C++20

constexpr std::strong_ordering operator<=>(const year& Left, const year& Right ) noexcept; // C++20

constexpr strong_ordering operator<=>(const year_month& Left, const year_month& Right) noexcept; // C++20

template<class Clock, class Duration1, three_way_comparable_with<Duration1> Duration2>
    constexpr auto operator<=>(const time_point<Clock, Duration1>& Left, const time_point<Clock, Duration2>& Right); // C++20

template<class Rep1, class Period1, class Rep2, class Period2>
  requires three_way_comparable<typename CT::rep>
    constexpr auto operator<=>(const duration<Rep1, Period1>& Left, const duration<Rep2, Period2>& Right);

2)
constexpr strong_ordering operator<=>(const month_day_last& Left, const month_day_last& Right) noexcept;

3)
constexpr strong_ordering operator<=>(const year_month_day_last& Left, const year_month_day_last& Right) noexcept;

4)
strong_ordering operator<=>(const time_zone_link& Left, const time_zone_link& Right) noexcept;

Parametry

Left, Right
Porównanie wartości day, , month_daytime_pointyeartime_zone_linkyear_monthmonthmonth_day_lastduration, . year_month_dayyear_month_day_last

Wartość zwracana

1)
0 jeśli Left == Right
< 0 jeśli Left < Right
> 0 jeśli Left > Right

2)
Odpowiednik: Left.month() <=> Right.month()

3)
Odpowiednik:

if (auto c = Left.year() <=> Right.year(); c != 0) return c;
return Left.month_day_last() <=> Right.month_day_last();

4)
Odpowiednik:

Left.name() <=> Right.name()

Przykład: `operator<=>`

// compile using: /std:c++latest
#include <iostream>
#include <chrono>

using namespace std::chrono; // for day and 'd' literals

int main()
{
    day d1{3};
    day d2{2};

    if ((d1 <=> d2) == 0)
    {
        std::cout << "equal\n";
    }
    else if ((d1 <=> d2) < 0)
    {
        std::cout << "d1 < d2\n";
    }
    else if ((d1 <=> d2) > 0)
    {
        std::cout << "d1 > d2\n";
    }

    std::cout << std::boolalpha << (1d <= 1d) << ' ' << (1d != 2d) << ' ' << (2d > 3d);

    return 0;
}

d1 < d2
true true false

`operator<<`

Wyprowadź następujące typy do strumienia:

// 1) day
template <class CharT, class Traits>
std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& os, const day& d); // C++20

// 2) hh_mm_ss
template<class CharT, class traits, class Duration>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const hh_mm_ss<Duration>& hms); // C++20

// 3) month
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const month& m); // C++20

// 4) month_day
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const month_day& md); // C++20

// 5) month_day_last
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const month_day_last& mdl); // C++20

// 6) month_weekday
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const month_weekday& mwd); // C++20

// 7) month_weekday_last
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const month_weekday_last& mwdl); // C++20

// 8) weekday
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const weekday& wd); // C++20

// 9) weekday_indexed
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const weekday_indexed& wdi); // C++20

// 10) weekday_last
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const weekday_last& wdl); // C++20

// 11) year
template <class CharT, class Traits>
std::basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const year& y); // C++20

// 12) year_month
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const year_month& ym); // C++20

// 13) year_month_day
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const year_month_day& ymd); // C++20

// 14) year_month_day_last
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const year_month_day_last& ymdl); // C++20

// 15) year_month_weekday
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const year_month_weekday& ymwd); // C++20

// 16) year_month_weekday_last
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const year_month_weekday_last& ymwdl); // C++20

// 17) tai_time
template<class CharT, class Traits, class Duration>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const tai_time<Duration>& t); // C++20

// 18) utc_time
template<class CharT, class Traits, class Duration>
basic_ostream<CharT, traits>&
operator<<(basic_ostream<CharT, Traits>& os, const utc_time<Duration>& t); // C++20

// 19) gps_time
template<class CharT, class Traits, class Duration>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const gps_time<Duration>& t); // C++20

// 20) local_time
template<class CharT, class Traits, class Duration>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const local_time<Duration>& t); // C++20

// 21) sys_info
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const sys_info& si);

// 22) local_info
template<class CharT, class Traits>
basic_ostream<charT, traits>&
operator<<(basic_ostream<CharT, Traits>& os, const local_info& li);

// 23) zoned_time
template<class CharT, class Traits, class Duration, class TimeZonePtr>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const zoned_time<Duration, TimeZonePtr>& zt);

Parametry

CharT
Typ danych pojedynczego znaku do odczytu ze strumienia i przechowywany w ciągu. Biblioteka Standardowa języka C++ udostępnia specjalizacje tego szablonu klasy z definicjami string typów elementów typu char, wstring, dla wchar_t, u16string dla char16_t, i u32string dla char32_t.

Traits
Opisuje CharT atrybuty dla i basic_istream basic_string specjalizacji.

os
Strumień wyjściowy do emitowania day wartości.

d
Wartość day do danych wyjściowych.

hms
Wartość hh_mm_ss do danych wyjściowych.

li
Wartość local_info do danych wyjściowych.

m
Wartość month do danych wyjściowych.

md
Wartość month_day do danych wyjściowych.

mdl
Wartość month_day_last do danych wyjściowych.

mwd
Wartość month_weekday do danych wyjściowych.

mwdl
Wartość month_weekday_last do danych wyjściowych.

si
Wartość sys_info do danych wyjściowych.

t
Dane local_timewyjściowe , gps_time, tai_timelub utc_time .

TimeZonePtr
Wskaźnik do time_zone przechowywany w obiekcie zoned_time.

wd
Wartość weekday do danych wyjściowych.

wdi
Wartość weekday_indexed do danych wyjściowych.

wdl
Wartość weekday_last do danych wyjściowych.

y
Wartość year do danych wyjściowych.

ym
Wartość year_month do danych wyjściowych.

ymd
Wartość year_month_day do danych wyjściowych.

ymdl
Wartość year_month_day_last do danych wyjściowych.

ymwd
Wartość year_month_weekday do danych wyjściowych.

ymwdl
Wartość year_month_weekday_last do danych wyjściowych.

zt
Wartość zoned_time do danych wyjściowych.

Wartość zwracana

Przekazany strumień wyjściowy os

Uwagi

1) Wartość day jest wynikiem wyjściowym jako liczba dziesiętna, z zerem wiodącym, jeśli wynikiem byłaby pojedyncza cyfra. Jeśli !d.ok()element " nie jest prawidłowym dniem" jest dołączany do danych wyjściowych.

2) Wartość jest wartością hh_mm_ss wyjściową jako hours:minutes:seconds:thousandths of seconds. Na przykład "00:00:05.721"

3) Skrócona nazwa miesiąca, używając ustawień regionalnych skojarzonych z os, to dane wyjściowe. Na przykład Jan. Jeśli !m.ok()parametr jest " is not a valid month" dołączany do danych wyjściowych.

4) Skrócona nazwa miesiąca, używając ustawień regionalnych skojarzonych z os, po którym następuje data, z zerem wiodącym, jeśli wynikiem będzie pojedyncza cyfra, jest dane wyjściowe. Na przykład Jan/05. Jeśli !md.ok()wartość , " is not a valid month" może zostać dołączona do danych wyjściowych miesiąca i "is not a valid day" może zostać dołączona do danych wyjściowych dnia. Na przykład 204 is not a valid month/204 is not a valid day.

5) Skrócona nazwa miesiąca, używając ustawień regionalnych skojarzonych z os, a następnie /last. Na przykład Jan/last.

6) Skrócona nazwa dnia tygodnia, używając ustawień regionalnych skojarzonych z os, a następnie nth weekday w miesiącu, który reprezentuje w nawiasach kwadratowych. Na przykład Mon[1].

7) Skrócona nazwa dnia tygodnia, używając ustawień regionalnych skojarzonych z elementem os, a następnie ostatniego dnia tygodnia w miesiącu, który reprezentuje w nawiasach kwadratowych. Na przykład Jan/Mon[last].

8) Skrócona nazwa dnia tygodnia, używając ustawień regionalnych skojarzonych z os, to dane wyjściowe. Jeśli !wd.ok()parametr jest " is not a valid weekday" dołączany do danych wyjściowych.

9) Skrócona nazwa dnia tygodnia, używając ustawień regionalnych skojarzonych z elementem os, to dane wyjściowe, a następnie dzień tygodnia miesiąca w nawiasach kwadratowych. Na przykład Mon[3]. Jeśli !wd.ok()wartość , " is not a valid weekday" może zostać dołączona do danych wyjściowych dnia tygodnia i "is not a valid index" może zostać dołączona do danych wyjściowych indeksu dnia tygodnia.

10) Ostatni dzień tygodnia miesiąca, używając ustawień regionalnych skojarzonych z elementem os, jest wynikiem, a następnie , a następnie [last]datą. Na przykład Tue[last] 2019-10-29. Jeśli !wd.ok()wartość , " is not a valid weekday" może zostać dołączona do danych wyjściowych dnia tygodnia i "is not a valid index" może zostać dołączona do danych wyjściowych indeksu dnia tygodnia.

11) Rok jest w lewo wypełniony z 0 (zero) do czterech cyfr, jeśli wynik będzie mniejszy. Jeśli !y.ok()parametr jest " is not a valid year" dołączany do danych wyjściowych.

12) Wynik year_month jest w postaci rrrr-mm-dd. Jeśli ym.ok funkcja zwraca falsewartość , " is not a valid date" zostanie dołączona.

13) Wynik year_month_day jest w postaci rrrr-mm-dd. Jeśli ymd.ok funkcja zwraca falsewartość , " is not a valid date" zostanie dołączona.

14) Parametr year_month_day_last jest wynikiem w postaci rrrr/miesiąc/ostatni. Na przykład 2020/May/last.

15) Element year_month_weekday jest wynikiem w postaci rrrr/miesiąc/dzień powszedni[indeks]. Na przykład 1996/Jan/Wed[1]

16) Element year_month_weekday_last jest wynikiem w postaci rrrr/miesiąc/dzień powszedni[ostatni]. Na przykład 1996/Jan/Wed[last]

17) Element tai_time jest wynikiem w postaci rrrr-mm-dd hh:mm:ss.ssssssss. Na przykład 2021-08-13 23:23:08.4358666

18) Element utc_time jest wynikiem w postaci rrrr-mm-dd hh:mm:ss.ssssssss. Na przykład 2021-08-13 23:23:08.4358666

19) Element gps_time jest wynikiem w postaci rrrr-mm-dd hh:mm:ss.ssssssss. Na przykład 2021-08-13 23:23:08.4358666

20) Wartość local_time jest wynikiem jako liczba sekund od epoki zegara. Są to dane wyjściowe, tak jakby według os << std::chrono::sys_time<Duration>(some_local_time.time_since_epoch());. Jeśli na przykład some_local_time jest to 18 sierpnia 2021 r. 13:13, dane wyjściowe to 1597792380.

21) W implementacji firmy Microsoft element jest wynikiem wyjściowym sys_info jako beginpola , end, offset, savei abbrev . Na przykład: begin: 2021-03-14 10:00:00, end: 2021-11-07 09:00:00, offset: -25200s, save: 60min, abbrev: PDT.

22) W implementacji firmy Microsoft element local_info jest wynikiem rrrr-mm-dd hh:mm::ss.sssssss. Na przykład 2021-09-17 13:55:59.6590120

23) Czas lokalny w zoned_time (uzyskany jako zt.get_local_time()) jest danymi wyjściowymi w formacie rrrr-mm-dd hh:mm:ss timezone. Na przykład 2021-09-15 10:45:00 GMT-6

Przykład: `operator<<`

// compile using: /std:c++latest
#include <iostream>
#include <chrono>

using namespace std::chrono;

int main()
{
    std::cout << utc_clock::now() << '\n';

    year_month ym{ 2021y / April };
    std::cout << ym;
    return 0;
}

2021-08-16 20:47:05.6299822
2021/Apr

`operator modulo`

Operator dla operacji modulo na .duration

1)
template <class Rep1, class Period1, class Rep2>
constexpr duration<Rep1, Period1, Rep2>::type
   operator%(
      const duration<Rep1, Period1>& Dur,
      const Rep2& Div);

2)
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr typename common_type<duration<Rep1, _Period1>, duration<Rep2, Period2>>::type
   operator%(
     const duration<Rep1, Period1>& Left,
     const duration<Rep2, Period2>& Right);

Parametry

Dur
Obiekt duration.

Div
Wartość całkowita.

Left
Dzielna. Modulo jest resztą po podzieleniu dywidendy przez dzielnika.

Right
Właściwy duration obiekt, dzielnika.

Wartość zwracana

1) Zwraca duration obiekt, którego długość interwału wynosi Dur modulo Div.

2) Zwraca wartość reprezentującą Left modulo Right.

`operator/` dla `duration`

Operator dzielenia obiektów duration .

1)
template <class Rep1, class Period1, class Rep2>
constexpr duration<typename common_type<Rep1, Rep2>::type, Period1>
   operator/(
     const duration<Rep1, Period1>& Dur,
     const Rep2& Div);

2)
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr typename common_type<Rep1, Rep2>::type
   operator/(
     const duration<Rep1, Period1>& Left,
     const duration<Rep2, Period2>& Right);

Parametry

Dur
Obiekt duration.

Div
Wartość całkowita.

Left\w obiekcie po lewej stronie duration .

Right
Właściwy duration obiekt.

Wartość zwracana

1) Obiekt czasu trwania, którego długość interwału Dur jest długością dzielenia przez wartość Div.

2) Współczynnik długości interwałów Left i Right.

Jeśli nie is_convertible<Rep2, common_type<Rep1, Rep2>>ma wartości true i Rep2 nie jest wystąpieniem elementu , pierwszy operator nie uczestniczy w rozwiązywaniu durationprzeciążeń. Aby uzyskać więcej informacji, zobacz <type_traits>.

`operator/` dla dat kalendarza

Zawiera składnię umożliwiającą tworzenie dat kalendarza w następujących formularzach:

miesiąc/dzień/rok
dzień/miesiąc/rok
rok/miesiąc/dzień

Możesz zastąpić dzień :

last
weekday[n] dla n-dniowego dnia miesiąca
weekday[last] dla ostatniego weekday miesiąca.

Daty częściowe można utworzyć w następujący sposób:

year_month ym = 2015y/April;
month_day md1 = April/4;
month_day md2 = 4d/April;

Liczby całkowite mogą być używane tak długo, jak interpretacja nie jest niejednoznaczna.

/////////  returns year_month

// 1
constexpr year_month
operator/(const year& y, const month& m) noexcept; // C++20

// 2
constexpr year_month
operator/(const year& y, int m) noexcept; // C++20
 
/////////  returns month_day

// 3
constexpr month_day
operator/(const month& m, const day& d) noexcept; // C++20

// 4
constexpr month_day
operator/(const month& m, int d) noexcept; // C++20

// 5
constexpr month_day
operator/(int m, const day& d) noexcept; // C++20

// 6
constexpr month_day
operator/(const day& d, const month& m) noexcept; // C++20

// 7
constexpr month_day
operator/(const day& d, int m) noexcept; // C++20

/////////  returns month_day_last

// 8
constexpr month_day_last
operator/(const month& m, last_spec) noexcept; // C++20

// 9
constexpr month_day_last
operator/(int m, last_spec) noexcept; // C++20

// 10
constexpr month_day_last
operator/(last_spec, const month& m) noexcept; // C++20

// 11
constexpr month_day_last
operator/(last_spec, int m) noexcept; // C++20

/////////  returns month_weekday

// 12
constexpr month_weekday
operator/(const month& m, const weekday_indexed& wdi) noexcept; // C++20

// 13
constexpr month_weekday
operator/(int m, const weekday_indexed& wdi) noexcept; // C++20

// 14
constexpr month_weekday
operator/(const weekday_indexed& wdi, const month& m) noexcept; // C++20

// 15
constexpr month_weekday
operator/(const weekday_indexed& wdi, int m) noexcept; // C++20

/////////  returns month_weekday_last

// 16
constexpr month_weekday_last
operator/(const month& m, const weekday_last& wdl) noexcept; // C++20

// 17
constexpr month_weekday_last
operator/(int m, const weekday_last& wdl) noexcept; // C++20

// 18
constexpr month_weekday_last
operator/(const weekday_last& wdl, const month& m) noexcept; // C++20

// 19
constexpr month_weekday_last
operator/(const weekday_last& wdl, int m) noexcept; // C++20

/////////  returns year_month_day

// 20
constexpr year_month_day
operator/(const year_month& ym, const day& d) noexcept; // C++20

// 21
constexpr year_month_day
operator/(const year_month& ym, int d) noexcept; // C++20

// 22
constexpr year_month_day
operator/(const year& y, const month_day& md) noexcept; // C++20

// 23
constexpr year_month_day
operator/(int y, const month_day& md) noexcept; // C++20

// 24
constexpr year_month_day
operator/(const month_day& md, const year& y) noexcept; // C++20

// 25
constexpr year_month_day
operator/(const month_day& md, int y) noexcept; // C++20

/////////  returns year_month_day_last

// 26
constexpr year_month_day_last
operator/(const year_month& ym, last_spec) noexcept; // C++20

// 27
constexpr year_month_day_last
operator/(const year& y, const month_day_last& mdl) noexcept; // C++20

// 28
constexpr year_month_day_last
operator/(int y, const month_day_last& mdl) noexcept; // C++20

// 29
constexpr year_month_day_last
operator/(const month_day_last& mdl, const year& y) noexcept; // C++20

// 30
constexpr year_month_day_last
operator/(const month_day_last& mdl, int y) noexcept; // C++20

/////////  returns year_month_weekday

// 31
constexpr year_month_weekday
operator/(const year_month& ym, const weekday_indexed& wdi) noexcept; // C++20

// 32
constexpr year_month_weekday
operator/(const year& y, const month_weekday& mwd) noexcept; // C++20

// 33
constexpr year_month_weekday
operator/(int y, const month_weekday& mwd) noexcept; // C++20

// 34
constexpr year_month_weekday
operator/(const month_weekday& mwd, const year& y) noexcept; // C++20

// 35
constexpr year_month_weekday
operator/(const month_weekday& mwd, int y) noexcept; // C++20

/////////  returns year_month_weekday_last

// 36
constexpr year_month_weekday_last
operator/(const year_month& ym, const weekday_last& wdl) noexcept; // C++20

// 37
constexpr year_month_weekday_last
operator/(const year& y, const month_weekday_last& mwdl) noexcept; // C++20

// 38
constexpr year_month_weekday_last
operator/(int y, const month_weekday_last& mwdl) noexcept; // C++20

// 39
constexpr year_month_weekday_last
operator/(const month_weekday_last& mwdl, const year& y) noexcept; // C++20

// 40
constexpr year_month_weekday_last
operator/(const month_weekday_last& mwdl, int y) noexcept; // C++20

Parametry

d
Dzień. Podana jako liczba całkowita w zakresie [1,31] lub jako day.

lastspec
Pusty typ tagu wskazujący ostatni element w sekwencji. Na przykład 2021y/May/last jest ostatnim dniem maja 2021 r.

m
Miesiąc. Podana jako liczba całkowita w zakresie [1,12] lub jako month.

md
Miesiąc i dzień.

mdl
Ostatni dzień określonego miesiąca.

mwd
N-ty dzień tygodnia określonego miesiąca.

mwdl
Ostatni dzień tygodnia określonego miesiąca.

wdi
Indeks dni powszedni (weekday_indexed). Na przykład weekday_indexed(Monday, 1) jest to pierwszy poniedziałek miesiąca.

wdl
Ostatni dzień tygodnia miesiąca. Na przykład Monday[last] jest to ostatni poniedziałek miesiąca.

y
Rok. Podana jako liczba całkowita lub jako .year

ym
Rok i miesiąc.

Wartość zwracana

1) year_month(y, m)
2) year_month(y, month(m))
3) month_day(m, d)
4) month_day(m, day(d))
5) month_day(month(m), d)
6) month_day(m, d)
7) month_day(month(m), d)
8) month_day_last(m)
9) month_day_last(month(m))
10) month_day_last(m)
11) month_day_last(month(m))
12) month_weekday(m, wdi)
13) month_weekday(month(m), wdi)
14) month_weekday(m, wdi)
15) month_weekday(month(m), wdi)
16) month_weekday_last(m, wdl)
17) month_weekday_last(month(m), wdl)
18) month_weekday_last(m, wdl)
19) month_weekday_last(month(m), wdl)
20) year_month_day(ym.year(), ym.month(), d)
21) year_month_day(ym.year(), ym.month(), day(d))
22) year_month_day(y, md.month(), md.day())
23) year_month_day(year(y), md.month(), md.day())
24) year_month_day(y, md.month(), md.day())
25) year_month_day(year(y), md.month(), md.day())
26) year_month_day_last(ym.year(), month_day_last(ym.month()))
27) year_month_day_last(y, mdl)
28) year_month_day_last(year(y), mdl)
29) year_month_day_last(y, mdl)
30) year_month_day_last(year(y), mdl)
31) year_month_weekday(ym.year(), ym.month(), wdi)
32) year_month_weekday(y, mwd.month(), mwd.weekday_indexed())
33) year_month_weekday(year(y), mwd.month(), mwd.weekday_indexed())
34) year_month_weekday(y, mwd.month(), mwd.weekday_indexed())
35) year_month_weekday(year(y), mwd.month(), mwd.weekday_indexed())
36) year_month_weekday_last(ym.year(), ym.month(), wdl)
37) year_month_weekday_last(y, mwdl.month(), mwdl.weekday_last())
38) year_month_weekday_last(year(y), mwdl.month(), mwdl.weekday_last())
39) year_month_weekday_last(y, mwdl.month(), mwdl.weekday_last())
40) year_month_weekday_last(year(y), mwdl.month(), mwdl.weekday_last())

Przykład: `operator/` w przypadku dat kalendarza

// compile using: /std:c++latest
#include <iostream>
#include <chrono>

using namespace std::chrono;

int main()
{
    month m{ July }; // Jul
    month_day md{ April / 4 }; // Apr/04
    month_day md2{ 4d / April }; // Apr/04
    month_day_last mdl{ January / last }; // Jan/last
    month_weekday mw{ 11 / Monday[1] }; // Nov/Mon[1]
    month_weekday_last mwl{ January / Monday[last] }; // Jan/Mon[last]
    weekday wd{ Monday }; // Mon
    weekday_indexed wdi{ Monday, 1 }; // Mon[1]
    year_month ym{ 2021y / April }; // 2021/Apr
    year_month_day ymd{ January / 1d / 2021y }; // 2021-01-01
    year_month_day ymd2{ 2021y / 5 / 7 }; // 2021-05-07
    year_month_day_last ymdl{ April / last / 1975 }; // 1975/Apr/last
    year_month_weekday ymw{ 1997y / January / Wednesday[1] }; // 1997/Jan/Wed[1]
    year_month_weekday_last ymwl{ 1997y / January / Wednesday[last] }; // 1997/Jan/Wed[last]
    int yearValue{ 2021 / 4 / 4 }; // 126

    std::cout << m << '\n' << md << '\n' << md2 << '\n' << mdl << '\n' << mw
        << '\n' << mwl << '\n' << wd << '\n' << wdi << '\n'
        << ym << '\n' << ymd << '\n' << ymd2 << '\n' << ymdl
        << '\n' << ymw << '\n' << ymwl << '\n' << yearValue;

    return 0;
}

Jul
Apr/04
Apr/04
Jan/last
Nov/Mon[1]
Jan/Mon[last]
Mon
Mon[1]
2021/Apr
2021-01-01
2021-05-07
1975/Apr/last
1997/Jan/Wed[1]
1997/Jan/Wed[last]
126

Udostępnij za pośrednictwem

<chrono>, operatory

operator+

Wartość zwracana

Przykład: operator+

Jednoargumentowy operator+

Wartość zwracana

operator-

Wartość zwracana

Przykład: operator-

Jednoargumentowy operator-

Wartość zwracana

Przykład: jednoargumentowy operator-

operator!=

Parametry

Wartość zwracana

operator*

Parametry

Wartość zwracana

operator<

Parametry

Wartość zwracana

operator<=

Parametry

Wartość zwracana

operator==

Parametry

Wartość zwracana

operator>

Parametry

Wartość zwracana

operator>=

Parametry

Wartość zwracana

operator<=>

Parametry

Wartość zwracana

Przykład: operator<=>

operator<<

Parametry

Wartość zwracana

Uwagi

Przykład: operator<<

operator modulo

Parametry

Wartość zwracana

operator/ dla duration

Parametry

Wartość zwracana

operator/ dla dat kalendarza

Parametry

Wartość zwracana

Przykład: operator/ w przypadku dat kalendarza

Opinia

Dodatkowe zasoby

`<chrono>`, operatory

`operator+`

Przykład: `operator+`

Jednoargumentowy `operator+`

`operator-`

Przykład: `operator-`

Jednoargumentowy `operator-`

Przykład: jednoargumentowy `operator-`

`operator!=`

`operator*`

`operator<`

`operator<=`

`operator==`

`operator>`

`operator>=`

`operator<=>`

Przykład: `operator<=>`

`operator<<`

Przykład: `operator<<`

`operator modulo`

`operator/` dla `duration`

`operator/` dla dat kalendarza

Przykład: `operator/` w przypadku dat kalendarza