Operatori `<chrono>`

Articolo
10/12/2023

`operator+`

Operatore di addizione per i tipi seguenti:

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

Valore restituito

1) Dopo la Left conversione e Right nel tipo comune, restituisce un duration oggetto con un conteggio dei tick uguale alla somma dei conteggi dei tick convertiti.

2-3) Restituire un time_point oggetto che rappresenta un punto nel tempo che viene spostato dall'intervallo Dur dal punto nel tempo Time.

4) Restituisce il risultato di d+ds.count(). Se il risultato non è compreso nell'intervallo [0, 255], il risultato non è specificato.

5) Restituisce il risultato di m+ms.count(). Se il risultato non rientra nell'intervallo [1, 12], viene ridotto modulo 12 e quindi +1.

6) Restituisce il risultato dell'aggiunta del numero di giorni e giorni feriali a weekday. Il risultato sarà modulo 7, quindi sempre nell'intervallo [0,6]

7) Restituisce il risultato dell'aggiunta dell'anno al numero di anni specificato.

8) Restituisce il risultato dell'aggiunta del numero di mesi e anni al mese e all'anno specificati.

9) Restituisce il risultato dell'aggiunta di mesi o anni a un oggetto year_month_day. Se ymd.month() è February e ymd.day() non è compreso nell'intervallo [1d, 28d], ok() può restituire false il risultato dell'addizione.

10) Restituisce (ymdl.year() / ymdl.month() + dm) / last. Nota: l'oggetto / usato qui non è un operatore di divisione. È l'operatore date.

11) Restituisce ymdl + dm.

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

13) Restituisce ymwd + dm.count().

14-15) Restituisce {ymwd.year()+dy, ymwd.month(), ymwd.weekday_indexed()}.

16) Restituisce (ymwdl.year() / ymwdl.month() + dm) / ymwdl.weekday_last(). Nota: l'oggetto / usato qui non è un operatore di divisione, ma l'operatore date.

17) Restituisce: ymwdl + dy

Esempio: `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]

Unario `operator+`

Applicare unario più ai tipi seguenti:

duration.

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

Valore restituito

Restituisce *this.

`operator-`

Operatore di sottrazione per i tipi seguenti:

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

Valore restituito

1) Dopo aver convertito le durate sottratte al tipo comune, restituisce un duration oggetto con un conteggio dei tick uguale al numero di tick in Right sottrazione dal numero di tick in Left.

2) Restituisce un time_point oggetto che rappresenta un punto nel tempo spostato dalla negazione dell'intervallo di tempo rappresentato da Dur, dal punto nel tempo specificato da Time.

3) Restituisce un duration oggetto che rappresenta l'intervallo di tempo tra Left e Right.

4) Restituisce il risultato di d-ds.count(). Se il risultato non è compreso nell'intervallo [0, 255], il risultato non è specificato.

5) Se m.ok() == true e ms.ok() == true, restituisce il risultato della sottrazione dei valori di due mesi o sottraendo il numero di mesi. Il risultato sarà compreso nell'intervallo [1, 12]. Se il risultato è negativo, viene eseguito il wrapping. Ad esempio, sottraendo un mese da gennaio (month m1{1} - months{1}; restituisce 12 (dicembre).

6) Restituisce la differenza in mesi tra Left e Right

7) Se Left.ok() == true e Right.ok() == true, restituisce un weekday oggetto nell'intervallo [days{0}, days{6}].

8) Restituisce il numero di giorni tra due giorni feriali.

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

10) Restituisce years(int(y) - int(y2)). Sottraendo due year valori si ottiene un std::chrono::yearsoggetto , che rappresenta la differenza negli anni tra y e y2. Esempio: 2021y-2000y genera years(21).

11) Restituisce il risultato della sottrazione di mesi o anni da un year_month valore.

12) Restituisce il risultato della sottrazione di anni di mesi da un year_month_day valore.

13) Restituisce il risultato della sottrazione del numero di mesi dal year_month_day_last valore. Essenzialmente: ymdl-dm.

14) Restituisce il risultato della sottrazione del numero di anni dal year_month_day_last valore. Essenzialmente: ymdl-dy.

15) Restituisce il risultato della sottrazione del numero di mesi dal year_month_weekday valore. Essenzialmente: ymwd-dm.

16) Restituisce il risultato della sottrazione del numero di anni dal year_month_weekday valore. Essenzialmente: ymwd-dy.

17) Restituisce il risultato della sottrazione del numero di mesi dal year_month_weekday_last valore. Essenzialmente: ymwdl-dm.

18) Restituisce il risultato della sottrazione del numero di anni dal year_month_weekday_last valore. Essenzialmente: ymwdl-dy.

Esempio: `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]

Unario `operator-`

Nega un oggetto duration.

constexpr common_type_t<duration> operator-() const;

Valore restituito

Restituisce una copia negata di *this

Esempio: unario `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!=`

Determina se:

1) Due duration oggetti non rappresentano lo stesso numero di tick.
2) Due time_point oggetti non rappresentano lo stesso punto nel tempo.

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);

Parametri

Left
L'oggetto duration o time_point a sinistra.

Right
L'oggetto duration o time_point a destra.

Valore restituito

1) Restituisce true se il numero di tick per il tipo comune a Left e Right non è uguale. In caso contrario, restituisce false.
2) Restituisce true se i due time_point oggetti non rappresentano lo stesso punto nel tempo. In caso contrario, restituisce false.

`operator*`

Operatore di moltiplicazione per gli oggetti duration. Dopo aver convertito l'oggetto durations moltiplicato nel tipo comune, restituisce un duration oggetto con un conteggio dei tick uguale alla moltiplicazione dei conteggi dei tick convertiti.

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);

Parametri

Dur
Oggetto duration.

Mult
Valore integrale.

Valore restituito

Restituisce un duration oggetto la cui lunghezza dell'intervallo viene Mult moltiplicata per la lunghezza di Dur.

1) A meno che is_convertible<Rep2, common_type<Rep1, Rep2>>non contenga true, questa funzione non partecipa alla risoluzione dell'overload. Per altre informazioni, vedere <type_traits>.

2) A meno che is_convertible<Rep1, common_type<Rep1, Rep2>>non contenga true, questa funzione non partecipa alla risoluzione dell'overload. Per altre informazioni, vedere <type_traits>.

`operator<`

1) Dopo la conversione degli durationoggetti rispetto al tipo comune, determina se il numero di tick per Left è minore di per Right.

2) Determina se il punto nel tempo dal momento in cui il periodo di è minore di Lefttime_point quello trascorso dall'epoca di time_point in 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);

Parametri

Left
L'oggetto duration o time_point a sinistra.

Right
L'oggetto duration o time_point a destra.

Valore restituito

1) Restituisce true se il numero di tick per Left è minore del numero di tick per Right. In caso contrario, la funzione restituisce false.

2) Restituisce true se Left precede Right. In caso contrario, restituisce false.

`operator<=`

1) Dopo la conversione di durations rispetto al tipo comune, determina se il numero di tick per Left è minore o uguale Righta .

2) Determina se il punto nel tempo dal momento in cui il periodo di Lefttime_point è minore o uguale all'ora dall'epoca di time_point in 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);

Parametri

Left
L'oggetto duration o time_point a sinistra.

Right
L'oggetto duration o time_point a destra.

Valore restituito

1) Restituisce true se il numero di tick per Left è minore o uguale al numero di tick per Right. In caso contrario, la funzione restituisce false.

2) Restituisce true se Left precede o è uguale a . Right In caso contrario, restituisce false.

`operator==`

Determina se:

1) duration gli oggetti rappresentano gli intervalli di tempo con la stessa lunghezza.
2) time_point gli oggetti rappresentano lo stesso punto nel tempo.
3) day gli oggetti rappresentano lo stesso giorno.
4) month gli oggetti rappresentano lo stesso mese.
5) month_day gli oggetti rappresentano lo stesso mese e giorno.
6) month_day_last gli oggetti rappresentano lo stesso mese.
7) month_weekday gli oggetti rappresentano lo stesso mese e n giorno feriale.
8) month_weekday_last gli oggetti rappresentano lo stesso mese e l'ultimo giorno feriale.
9) weekday gli oggetti rappresentano lo stesso giorno feriale.
10) weekday_last gli oggetti rappresentano lo stesso giorno feriale del mese.
11) weekday_indexed rappresenta lo stesso indice della settimana.
12) year rappresentano lo stesso anno.
13) year_month rappresentano lo stesso anno e mese.
14) year_month_day rappresentano lo stesso anno, mese e giorno.
15) year_month_day_last rappresentano lo stesso giorno dell'anno e del mese.
16) year_month_weekday rappresentano lo stesso giorno feriale, anno e mese.
17) year_month_weekday_last rappresentano lo stesso giorno feriale del mese, dell'anno e del mese.
18) time_zone_link hanno lo stesso name. Il target nome non viene considerato.
19) zoned_time rappresentano lo stesso fuso orario e fuso orario.

// 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

Parametri

Left
Oggetto sinistro da confrontare, ad esempio Left == Right

Right
Oggetto a destra da confrontare.

Valore restituito

1) Restituisce true se il numero di tick per il tipo comune a Left e Right sono uguali. In caso contrario, restituisce false.
2) Restituisce true se Left e Right rappresentano lo stesso punto nel tempo. In caso contrario, restituisce false.
3-17) Restituisce true se Left e Right hanno lo stesso valore. In caso contrario, restituisce false.
18) Restituisce true se Left.name() == Right.name(). In caso contrario, restituisce *false*.
19) Restituisce true se Left.get_time_zone() == _Right.get_time_zone() && Left.get_sys_time() == Right.get_sys_time();

`operator>`

1) Dopo la conversione di durations rispetto al tipo comune, determina se il numero di tick per Left è maggiore di per Right.

2) Determina se il punto nel tempo trascorso dall'epoca di è maggiore del Lefttime_point tempo trascorso dal periodo di time_point in 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);

Parametri

Left
L'oggetto duration o time_point a sinistra.

Right
L'oggetto duration o time_point a destra.

Valore restituito

1) Restituisce true se il numero di tick per Left è maggiore del numero di tick per Right. In caso contrario, la funzione restituisce false.

2) Restituisce true se Left viene dopo Right. In caso contrario, restituisce false.

`operator>=`

1) Dopo la conversione di durations rispetto al tipo comune, determina se il numero di tick per Left è maggiore o uguale a Right.

2) Determina se il punto nel tempo dal momento in cui il periodo di Lefttime_point è maggiore o uguale all'ora dall'epoca di time_point in 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);

Parametri

Left
L'oggetto duration o time_point a sinistra.

Right
L'oggetto duration o time_point a destra.

Valore restituito

1) Restituisce true se il numero di tick per Left è maggiore o uguale al numero di tick per Right. In caso contrario, la funzione restituisce false.

2) Restituisce true se Left viene dopo o è uguale a . Right In caso contrario, restituisce false.

`operator<=>`

L'operatore spaceship, con operator==, sintetizza gli operatori per <, ><=, >=, e != per i tipi seguenti:

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;

Parametri

Left, Right
Oggetto day, durationmonth, month_day, month_day_last, yeartime_zone_linkyear_monthtime_point, year_month_dayyear_month_day_last da confrontare.

Valore restituito

1)
0 se Left == Right
< 0 se Left < Right
> 0 se Left > Right

2)
Equivalente a: Left.month() <=> Right.month()

3)
Equivalente a:

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

4)
Equivalente a:

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

Esempio: `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<<`

Eseguire l'output dei tipi seguenti in un flusso:

// 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);

Parametri

CharT
Tipo di dati di un singolo carattere da leggere dal flusso e archiviato nella stringa. La libreria standard C++ fornisce specializzazioni di questo modello di classe, con le definizioni dei tipi string per gli elementi di tipo char, wstring, per wchar_t, u16string per char16_te u32string per char32_t.

Traits
Descrive gli CharT attributi per la basic_string specializzazione e basic_istream .

os
Flusso di output in cui generare il day valore.

d
Oggetto day da restituire.

hms
Oggetto hh_mm_ss da restituire.

li
Oggetto local_info da restituire.

m
Oggetto month da restituire.

md
Oggetto month_day da restituire.

mdl
Oggetto month_day_last da restituire.

mwd
Oggetto month_weekday da restituire.

mwdl
Oggetto month_weekday_last da restituire.

si
Oggetto sys_info da restituire.

t
Oggetto local_time, gps_time, tai_timeo utc_time per l'output.

TimeZonePtr
Puntatore al time_zone archiviato zoned_timein .

wd
Oggetto weekday da restituire.

wdi
Oggetto weekday_indexed da restituire.

wdl
Oggetto weekday_last da restituire.

y
Oggetto year da restituire.

ym
Oggetto year_month da restituire.

ymd
Oggetto year_month_day da restituire.

ymdl
Oggetto year_month_day_last da restituire.

ymwd
Oggetto year_month_weekday da restituire.

ymwdl
Oggetto year_month_weekday_last da restituire.

zt
Oggetto zoned_time da restituire.

Valore restituito

Flusso di output passato, os

Osservazioni:

1) Il day valore viene restituito come numero decimale, con zero iniziale se il risultato sarà una singola cifra. Se !d.ok(), " non è un giorno valido" viene aggiunto all'output.

2) Il hh_mm_ss valore viene restituito come ore:minuti:secondi:millesimi di secondi. Ad esempio, "00:00:05.721"

3) Il nome del mese abbreviato, usando le impostazioni locali associate a os, è l'output. Ad esempio: Jan. Se !m.ok(), viene " is not a valid month" aggiunto all'output.

4) Il nome del mese abbreviato, utilizzando le impostazioni locali associate a os, seguito dalla data, con uno zero iniziale se il risultato sarebbe una singola cifra, viene restituito. Ad esempio: Jan/05. Se !md.ok(), " is not a valid month" può essere aggiunto all'output del mese e "is not a valid day" può essere aggiunto all'output del giorno. Ad esempio: 204 is not a valid month/204 is not a valid day.

5) Nome del mese abbreviato, utilizzando le impostazioni locali associate a os, seguito da /last. Ad esempio: Jan/last.

6) Il nome abbreviato del giorno della settimana, utilizzando le impostazioni locali associate a os, seguito dall'n° giorno feriale del mese che rappresenta tra parentesi quadre. Ad esempio: Mon[1].

7) Il nome abbreviato del giorno della settimana, utilizzando le impostazioni locali associate a os, seguito dall'ultimo giorno feriale del mese rappresentato tra parentesi quadre. Ad esempio: Jan/Mon[last].

8) Il nome abbreviato del giorno della settimana, usando le impostazioni locali associate a os, viene restituito. Se !wd.ok(), viene " is not a valid weekday" aggiunto all'output.

9) Il nome abbreviato del giorno della settimana, usando le impostazioni locali associate a os, è l'output, seguito dal giorno feriale del mese tra parentesi quadre. Ad esempio: Mon[3]. Se !wd.ok(), " is not a valid weekday" può essere aggiunto al giorno dell'output della settimana e "is not a valid index" può essere aggiunto all'output dell'indice del giorno feriale.

10) L'ultimo giorno feriale di un mese, utilizzando le impostazioni locali associate a os, viene restituito, seguito da [last], seguito dalla data. Ad esempio: Tue[last] 2019-10-29. Se !wd.ok(), " is not a valid weekday" può essere aggiunto al giorno dell'output della settimana e "is not a valid index" può essere aggiunto all'output dell'indice del giorno feriale.

11) L'anno viene riempito a sinistra con 0 (zero) a quattro cifre se il risultato sarebbe minore di quello. Se !y.ok(), viene " is not a valid year" aggiunto all'output.

12) L'output year_month è nel formato aaaa-mm-gg. Se ym.ok restituisce false, " is not a valid date" viene aggiunto .

13) L'output year_month_day è nel formato aaaa-mm-gg. Se ymd.ok restituisce false, " is not a valid date" viene aggiunto .

14) L'output year_month_day_last è nel formato aaaaa/mese/ultimo. Ad esempio: 2020/May/last.

15) L'output year_month_weekday è nel formato aaaaa/mese/giorno feriale[indice]. Ad esempio, 1996/Jan/Wed[1]

16) L'output year_month_weekday_last è nel formato aaaaa/mese/giorno feriale[last]. Ad esempio, 1996/Jan/Wed[last]

17) L'output tai_time è nel formato aaaa-mm-gg hh:mm:ss.ssssssss. Ad esempio, 2021-08-13 23:23:08.4358666

18) L'output utc_time è nel formato aaaa-mm-gg hh:mm:ss.ssssss. Ad esempio, 2021-08-13 23:23:08.4358666

19) L'output gps_time è nel formato aaaa-mm-gg hh:mm:ss.ssssss. Ad esempio, 2021-08-13 23:23:08.4358666

20) Viene local_time restituito come numero di secondi dall'epoca dell'orologio. L'output è come se fosse os << std::chrono::sys_time<Duration>(some_local_time.time_since_epoch());. Ad esempio, se some_local_time è il 18 agosto 2021 3:13pm, l'output è 1597792380.

21) Nell'implementazione di Microsoft, viene restituito un sys_info oggetto come begincampi , , endoffsetsave, e abbrev . Ad esempio: begin: 2021-03-14 10:00:00, end: 2021-11-07 09:00:00, offset: -25200s, save: 60min, abbrev: PDT

22) Nell'implementazione di Microsoft, un local_info viene restituito come aa-mm-gg hh:mm::sssssss. Ad esempio, 2021-09-17 13:55:59.6590120

23) L'ora zoned_time locale in (ottenuta come zt.get_local_time()) viene restituita usando il formato aaaa-mm-gg hh:mm:ss fuso orario. Ad esempio, 2021-09-15 10:45:00 GMT-6

Esempio: `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`

Operatore per operazioni modulo su 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);

Parametri

Dur
Oggetto duration.

Div
Valore integrale.

Left
Dividendo. Il modulo è il resto dopo aver diviso il dividendo per il divisore.

Right
Oggetto destro duration , divisore.

Valore restituito

1) Restituisce un duration oggetto la cui lunghezza dell'intervallo è Dur modulo Div.

2) Restituisce un valore che rappresenta Left il modulo Right.

`operator/` per `duration`

Operatore di divisione per oggetti 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);

Parametri

Dur
Oggetto duration.

Div
Valore integrale.

Left\w L'oggetto sinistro duration .

Right
L'oggetto duration corretto.

Valore restituito

1) Oggetto duration la cui lunghezza dell'intervallo è la lunghezza di Dur diviso per il valore Div.

2) Rapporto tra le lunghezze degli intervalli di Left e Right.

A meno che is_convertible<Rep2, common_type<Rep1, Rep2>>non contenga true e Rep2 non sia un'istanza di duration, il primo operatore non partecipa alla risoluzione dell'overload. Per altre informazioni, vedere <type_traits>.

`operator/` per le date del calendario

Fornisce la sintassi per creare date di calendario nei formati seguenti:

mese/giorno/anno
giorno/mese/anno
anno/mese/giorno

È possibile sostituire day con:

last
weekday[n] per il n° giorno del mese
weekday[last] per l'ultimo weekday mese.

Le date parziali possono essere formate nel modo seguente:

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

I numeri interi possono essere usati purché l'interpretazione non sia ambigua.

/////////  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

Parametri

d
Il giorno. Specificato come numero intero nell'intervallo [1,31], o come .day

lastspec
Tipo di tag vuoto che indica l'ultimo elemento nella sequenza di s. Ad esempio, 2021y/May/last è l'ultimo giorno di maggio 2021.

m
Il mese. Specificato come numero intero nell'intervallo [1,12], o come .month

md
Mese e giorno.

mdl
Ultimo giorno del mese specificato.

mwd
N-giorno feriale del mese specificato.

mwdl
Ultimo giorno feriale del mese specificato.

wdi
Indice del giorno feriale (weekday_indexed). Ad esempio, weekday_indexed(Monday, 1) è il primo lunedì di un mese.

wdl
Ultimo giorno feriale di un mese. Ad esempio, Monday[last] è l'ultimo lunedì di un mese.

y
L'anno. Fornito come numero intero o come .year

ym
Anno e mese.

Valore restituito

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())

Esempio: `operator/` per le date del calendario

// 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

Condividi tramite

Operatori <chrono>

operator+

Valore restituito

Esempio: operator+

Unario operator+

Valore restituito

operator-

Valore restituito

Esempio: operator-

Unario operator-

Valore restituito

Esempio: unario operator-

operator!=

Parametri

Valore restituito

operator*

Parametri

Valore restituito

operator<

Parametri

Valore restituito

operator<=

Parametri

Valore restituito

operator==

Parametri

Valore restituito

operator>

Parametri

Valore restituito

operator>=

Parametri

Valore restituito

operator<=>

Parametri

Valore restituito

Esempio: operator<=>

operator<<

Parametri

Valore restituito

Osservazioni:

Esempio: operator<<

operator modulo

Parametri

Valore restituito

operator/ per duration

Parametri

Valore restituito

operator/ per le date del calendario

Parametri

Valore restituito

Esempio: operator/ per le date del calendario

Commenti e suggerimenti

Risorse aggiuntive

Operatori `<chrono>`

`operator+`

Esempio: `operator+`

Unario `operator+`

`operator-`

Esempio: `operator-`

Unario `operator-`

Esempio: unario `operator-`

`operator!=`

`operator*`

`operator<`

`operator<=`

`operator==`

`operator>`

`operator>=`

`operator<=>`

Esempio: `operator<=>`

`operator<<`

Esempio: `operator<<`

`operator modulo`

`operator/` per `duration`

`operator/` per le date del calendario

Esempio: `operator/` per le date del calendario