Operadores `<chrono>`

Artigo
04/01/2024

`operator+`

Operador de adição para os seguintes tipos:

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

Valor retornado

1) Após converter Left e Right para seu tipo comum, retorna um duration com uma contagem de tiques igual à soma das contagens de tiques convertidas.

2-3) Retorna um objeto time_point que representa um ponto no tempo que é deslocado pelo intervalo Dur do ponto no tempo Time.

4) Retorna o resultado de d+ds.count(). Se o resultado estiver fora do intervalo [0, 255], o resultado não será especificado.

5) Retorna o resultado de m+ms.count(). Se o resultado estiver fora do intervalo [1, 12], será reduzido o módulo 12 e colocado sobre +1.

6) Retorna o resultado da adição do número de dias e dias da semana ao weekday. O resultado será módulo 7, então sempre no intervalo [0,6]

7) Retorna o resultado da adição do ano ao número de anos especificado.

8) Retorna o resultado da adição do número de meses e anos correspondentes ao mês e ano especificados.

9) Retorna o resultado da adição de meses ou anos a um year_month_day. Se ymd.month() for February e ymd.day() não estiver no intervalo [1d, 28d], ok() poderá retornar false como o resultado da adição.

10) Retorna (ymdl.year() / ymdl.month() + dm) / last. Observação: o / usado aqui não é um operador de divisão. É o operador de data.

11) Retorna ymdl + dm.

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

13) Retorna ymwd + dm.count().

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

16) Retorna (ymwdl.year() / ymwdl.month() + dm) / ymwdl.weekday_last(). Observação: o / usado aqui não é um operador de divisão, mas o operador de data.

17) Retorna: ymwdl + dy

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

`operator+` unário

Aplique adição unária aos seguintes tipos:

duration.

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

Valor retornado

Retorna *this

`operator-`

Operador de subtração para os seguintes tipos:

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

Valor retornado

1) Após converter as durações subtraídas para seu tipo comum, retorna um duration com uma contagem de tiques igual ao número de tiques em Right subtraído do número de tiques em Left.

2) Retorna um time_point que representa um ponto no tempo que é deslocado pela negação do intervalo de tempo representado por Dur, a partir do momento em que é especificado por Time.

3) Retorna um objeto duration que representa o intervalo de tempo entre Left e Right.

4) Retorna o resultado de d-ds.count(). Se o resultado estiver fora do intervalo [0, 255], o resultado não será especificado.

5) Se m.ok() == true e ms.ok() == true, retornará o resultado da subtração dos valores de dois meses ou da subtração do número de meses. O resultado estará no intervalo [1, 12]. Se o resultado for negativo, ele será arredondado. Por exemplo, subtraindo um mês de janeiro (month m1{1} - months{1}; resulta em 12 (dezembro).

6) Retorna a diferença, em meses, entre Left e Right

7) Se Left.ok() == true e Right.ok() == true, retornará um weekday no intervalo [days{0}, days{6}].

8) Retorna o número de dias entre dois dias da semana.

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

10) Retorna years(int(y) - int(y2)). A subtração de dois valores year resulta em um std::chrono::years, que representa a diferença em anos entre y e y2. Por exemplo, 2021y-2000y produz years(21).

11) Retorna o resultado da subtração de meses ou anos de um valor year_month.

12) Retorna o resultado da subtração de meses anos de um valor year_month_day.

13) Retorna o resultado da subtração do número de meses do valor year_month_day_last. Essencialmente: ymdl-dm.

14) Retorna o resultado da subtração do número de anos do valor year_month_day_last. Essencialmente: ymdl-dy.

15) Retorna o resultado da subtração do número de meses do valor year_month_weekday. Essencialmente: ymwd-dm.

16) Retorna o resultado da subtração do número de anos do valor year_month_weekday. Essencialmente: ymwd-dy.

17) Retorna o resultado da subtração do número de meses do valor year_month_weekday_last. Essencialmente: ymwdl-dm.

18) Retorna o resultado da subtração do número de anos do valor year_month_weekday_last. Essencialmente: ymwdl-dy.

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

`operator-` unário

Nega um duration.

constexpr common_type_t<duration> operator-() const;

Valor retornado

Retorna uma cópia negada de *this

Exemplo: `operator-` unário

// 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) Dois objetos duration não representam o mesmo número de tiques.
2) Dois time_point objetos não representam o mesmo ponto no 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);

Parâmetros

Left
O objeto duration ou time_point à esquerda.

Right
O objeto duration ou time_point à direita.

Valor retornado

1) Retornará true se o número de tiques para o tipo comum para Left e Right não for igual. Caso contrário, retorna false.
2) Retornará true se os dois objetos time_point não representarem o mesmo ponto no tempo. Caso contrário, retorna false.

`operator*`

Operador de multiplicação para objetos duration. Depois de converter os durations que estão sendo multiplicados para seu tipo comum, retornará um duration com uma contagem de tiques igual à multiplicação das contagens de tiques convertidas.

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

Parâmetros

Dur
Um objeto duration.

Mult
Um valor integral.

Valor retornado

Retorna um objeto duration cujo comprimento do intervalo é Mult multiplicado pelo comprimento de Dur.

1) A menos que is_convertible<Rep2, common_type<Rep1, Rep2>>mantidatrue, esta função não participará da resolução de sobrecarga. Para obter mais informações, confira <type_traits>.

2) A menos que is_convertible<Rep1, common_type<Rep1, Rep2>>mantida true, essa função não participará da resolução de sobrecarga. Para obter mais informações, confira <type_traits>.

`operator<`

1) Depois de converter os durations comparados ao seu tipo comum, determina se o número de tiques para Left é menor que para Right.

2) Determina se o momento desde a época do Lefttime_point é menor que o tempo desde a época de time_point em 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);

Parâmetros

Left
O objeto duration ou time_point à esquerda.

Right
O objeto duration ou time_point à direita.

Valor retornado

1) Retornará true se o número de tiques para Left for menor que o número de tiques para Right. Caso contrário, a função retorna false.

2) Retornará true se Left for precedido de Right. Caso contrário, retorna false.

`operator<=`

1) Depois de converter os durations comparados ao seu tipo comum, determina se o número de tiques para Left é menor ou igual a Right.

2) Determina se o ponto no tempo desde a época do Lefttime_point é menor ou igual ao tempo desde a época do time_point em 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);

Parâmetros

Left
O objeto duration ou time_point à esquerda.

Right
O objeto duration ou time_point à direita.

Valor retornado

1) Retornará true se o número de tiques de Left for menor ou igual ao número de tiques de Right. Caso contrário, a função retorna false.

2) Retornará true se Left for precedido ou igual a Right. Caso contrário, retorna false.

`operator==`

Determina se:

1) Objetos de duration representam intervalos de tempo que têm o mesmo comprimento.
2) Objetos de time_point representam o mesmo ponto no tempo.
3) Objetos de day representam o mesmo dia.
4) Objetos de month representam o mesmo mês.
5) Objetos de month_day representam o mesmo mês e dia.
6) Objetos de month_day_last representam o mesmo mês.
7) Objetos de month_weekday representam o mesmo mês e n-ésimo dia da semana.
8) Objetos de month_weekday_last representam o mesmo mês e último dia da semana.
9) Objetos de weekday representam o mesmo dia da semana.
10) Objetos de weekday_last representam o mesmo último dia da semana do mês.
11) weekday_indexed representa o mesmo índice durante a semana.
12) year representa o mesmo ano.
13) year_month representa o mesmo ano e mês.
14) year_month_day representa o mesmo ano, mês e dia.
15) year_month_day_last representa o mesmo último dia do ano e mês.
16) year_month_weekday representa o mesmo dia da semana, ano e mês.
17) year_month_weekday_last representa o mesmo último dia da semana do mês, ano e mês.
18) time_zone_link tem o mesmo name. O nome target não é considerado.
19) zoned_time representa o mesmo horário e fuso horário.

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

Parâmetros

Left
O objeto esquerdo ao qual comparar, por exemplo,Left == Right

Right
O objeto à direita a ser comparado.

Valor retornado

1) Retornará true se o número de tiques para o tipo comum Left e Right forem iguais. Caso contrário, retorna false.
2) Retornará true se Left e Right representarem o mesmo ponto no tempo. Caso contrário, retorna false.
3-17) Retornará true se Left e Right tiverem o mesmo valor. Caso contrário, retorna false.
18) Retornará true se Left.name() == Right.name(). Caso contrário, retorna *false*.
19) Retornará true se Left.get_time_zone() == _Right.get_time_zone() && Left.get_sys_time() == Right.get_sys_time();

`operator>`

1) Depois de converter os durations comparados ao seu tipo comum, determina se o número de tiques para Left é maior que para Right.

2) Determina se o momento desde a época do Lefttime_point é maior que o tempo desde a época do time_point em 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);

Parâmetros

Left
O objeto duration ou time_point à esquerda.

Right
O objeto duration ou time_point à direita.

Valor retornado

1) Retornará true se o número de tiques para Left for maior que o número de tiques para Right. Caso contrário, a função retorna false.

2) Retornará true se Left vier depois de Right. Caso contrário, retorna false.

`operator>=`

1) Após converter os durations sendo comparados ao seu tipo comum, determina se o número de tiques para Left é maior ou igual a Right.

2) Determina se o ponto no tempo desde a época do Lefttime_point é maior ou igual ao tempo desde a época do time_point em 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);

Parâmetros

Left
O objeto duration ou time_point à esquerda.

Right
O objeto duration ou time_point à direita.

Valor retornado

1) Retornará true se o número de tiques para Left for maior ou igual ao número de tiques para Right. Caso contrário, a função retorna false.

2) Retornará true se Left vier depois ou for igual a Right. Caso contrário, retorna false.

`operator<=>`

O operador de espaçonave, com operator==, sintetiza operadores para <, <=, >, >= e != para os seguintes tipos:

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;

Parâmetros

Left, Right
Os day, duration, month, month_day, month_day_last, time_point, time_zone_link, year, year_month, year_month_day, year_month_day_last a serem comparados.

Valor retornado

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

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

Gere os seguintes tipos para um fluxo:

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

Parâmetros

CharT
O tipo de dados de um único caractere a ser lido do fluxo e armazenado na cadeia de caracteres. A Biblioteca Padrão C++ oferece especializações desta classe de modelo, com as definições de tipo string para elementos do tipo char, wstring, de wchar_t, u16string de char16_t e u32string de char32_t.

Traits
Descreve atributos CharT para a especialização basic_string e basic_istream.

os
O fluxo de saída para o qual emitir o valor de day.

d
O day a ser emitido.

hms
O hh_mm_ss a ser emitido.

li
O local_info a ser emitido.

m
O month a ser emitido.

md
O month_day a ser emitido.

mdl
O month_day_last a ser emitido.

mwd
O month_weekday a ser emitido.

mwdl
O month_weekday_last a ser emitido.

si
O sys_info a ser emitido.

t
O local_time, gps_time, tai_time, ou utc_time a ser emitido.

TimeZonePtr
Um ponteiro para o time_zone armazenado no zoned_time.

wd
O weekday a ser emitido.

wdi
O weekday_indexed a ser emitido.

wdl
O weekday_last a ser emitido.

y
O year a ser emitido.

ym
O year_month a ser emitido.

ymd
O year_month_day a ser emitido.

ymdl
O year_month_day_last a ser emitido.

ymwd
O year_month_weekday a ser emitido.

ymwdl
O year_month_weekday_last a ser emitido.

zt
O zoned_time a ser emitido.

Valor retornado

O fluxo de saída que você passou, os

Comentários

1) O valor day é gerado como um número decimal, com um zero à esquerda se o resultado for um único dígito. Se !d.ok(), "não é um dia válido" será anexado à saída.

2) O valor hh_mm_ss é gerado como horas:minutos:segundos:milésimos de segundos. Por exemplo, "00:00:05.721"

3) O nome do mês abreviado, usando a localidade associada a os, é gerado. Por exemplo, Jan. Se !m.ok(), então " is not a valid month" será anexado à saída.

4) O nome do mês abreviado, usando a localidade associada a os, seguido pela data, com um zero à esquerda se o resultado for um único dígito, será gerado. Por exemplo, Jan/05. Se !md.ok(), então " is not a valid month" poderá ser anexado à saída do mês e "is not a valid day" à saída do dia. Por exemplo, 204 is not a valid month/204 is not a valid day.

5) O nome do mês abreviado, usando a localidade associada a os, seguido por /last. Por exemplo, Jan/last.

6) O nome abreviado do dia da semana, usando a localidade associada a os, seguido pelo e-nésimo dia da semana no mês que representa entre colchetes. Por exemplo, Mon[1].

7) O nome abreviado do dia da semana, usando a localidade associada a os, seguido do último dia da semana do mês que representa entre colchetes. Por exemplo, Jan/Mon[last].

8) O nome do dia da semana abreviado, usando a localidade associada a os, será gerado. Se !wd.ok(), então " is not a valid weekday" será anexado à saída.

9) O nome do dia da semana abreviado, usando a localidade associada a os, será gerado, seguido pelo dia da semana do mês entre colchetes. Por exemplo, Mon[3]. Se !wd.ok(), então " is not a valid weekday" poderá ser acrescentado ao dia da saída da semana e "is not a valid index" será acrescentado à saída do índice durante a semana.

10) O último dia da semana de um mês, usando a localidade associada os, é a saída, seguido por [last], e pela data. Por exemplo, Tue[last] 2019-10-29. Se !wd.ok(), então " is not a valid weekday" poderá ser acrescentado ao dia da saída da semana e "is not a valid index" será acrescentado à saída do índice durante a semana.

11) O ano é preenchido à esquerda com 0 (zero) a quatro dígitos se o resultado for menor que isso. Se !y.ok(), então " is not a valid year" será anexado à saída.

12) O year_month é gerado no formato aaaa-mm-dd. Se ym.ok retornar false, " is not a valid date" será anexado.

13) O year_month_day é gerado no formato aaaa-mm-dd. Se ymd.ok retornar false, " is not a valid date" será anexado.

14) O year_month_day_last é gerado no formato aaaa/mês/último. Por exemplo, 2020/May/last.

15) O year_month_weekday é gerado no formato aaaa/mês/dia da semana[índice]. Por exemplo, 1996/Jan/Wed[1]

16) O year_month_weekday_last é gerado no formato aaaa/mês/dia da semana[último]. Por exemplo, 1996/Jan/Wed[last]

17) O tai_time é gerado no formato aaaa-mm-dd hh:mm:ss.sssssss. Por exemplo, 2021-08-13 23:23:08.4358666

18) O utc_time é gerado no formato aaaa-mm-dd hh:mm:ss.sssssss. Por exemplo, 2021-08-13 23:23:08.4358666

19) O gps_time é gerado no formato aaaa-mm-dd hh:mm:ss.sssssss. Por exemplo, 2021-08-13 23:23:08.4358666

20) O local_time é gerado como o número de segundos desde a época do relógio. É emitido como se fosse por os << std::chrono::sys_time<Duration>(some_local_time.time_since_epoch());. Por exemplo, se some_local_time for 18 de agosto de 2021 15h13, a saída será 1597792380.

21) Na implementação da Microsoft, um sys_info é gerado como seus campos begin, end, offset, save e abbrev. Por exemplo: begin: 2021-03-14 10:00:00, end: 2021-11-07 09:00:00, offset: -25200s, save: 60min, abbrev: PDT

22) Na implementação da Microsoft, um local_info é gerado como aaaa-mm-dd hh:mm::ss.ssssss. Por exemplo, 2021-09-17 13:55:59.6590120

23) A hora local em zoned_time (obtida como zt.get_local_time()) é emitida usando o formato aaaa-mm-dd hh:mm:ss fuso horário. Por exemplo, 2021-09-15 10:45:00 GMT-6

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

Operador para operações de módulo em 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);

Parâmetros

Dur
Um objeto duration.

Div
Um valor integral.

Left
O dividendo. O módulo é o resto depois de dividir o dividendo pelo divisor.

Right
O objeto duration à direita, o divisor.

Valor retornado

1) Retorna um objeto duration cujo comprimento do intervalo é Dur módulo Div.

2) Retorna um valor que representa Left módulo Right.

`operator/` para `duration`

Operador de divisão para objetos 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);

Parâmetros

Dur
Um objeto duration.

Div
Um valor integral.

Left\w O objeto duration à esquerda.

Right
O objeto duration à direita.

Valor retornado

1) Um objeto de duração cujo comprimento do intervalo é o comprimento de Dur dividido pelo valor Div.

2) A razão dos comprimentos de intervalo de Left e Right.

A menos que is_convertible<Rep2, common_type<Rep1, Rep2>>seja verdadeiro e Rep2 não seja uma instanciação de duration, o primeiro operador não participa da resolução de sobrecarga. Para obter mais informações, confira <type_traits>.

`operator/` para datas do calendário

Fornece sintaxe para criar datas de calendário nas seguintes formas:

mês/dia/ano
dia/mês/ano
dia/mês/ano

Você pode substituir o dia por:

last
weekday[n] para o e-nésimo dia do mês
weekday[last] para o último weekday do mês.

As datas parciais podem ser formadas da seguinte maneira:

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

Inteiros podem ser usados desde que a interpretação não seja ambígua.

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

Parâmetros

d
O dia. Fornecido como um inteiro no intervalo [1,31] ou como um day.

lastspec
Um tipo de marca vazio que indica o último item na sequência s. Por exemplo, 2021y/May/last é o último dia de maio de 2021.

m
O mês. Fornecido como um inteiro no intervalo [1,12], ou como um month.

md
O mês e o dia.

mdl
O último dia do mês especificado.

mwd
O n-ésimo dia da semana do mês especificado.

mwdl
O último dia da semana do mês especificado.

wdi
Um índice de dia da semana (weekday_indexed). Por exemplo, weekday_indexed(Monday, 1) é a primeira segunda-feira de um mês.

wdl
O último dia da semana de um mês. Por exemplo, Monday[last] é a última segunda-feira de um mês.

y
O ano. Fornecido como um inteiro ou como um year.

ym
O ano e o mês.

Valor retornado

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

Exemplo: `operator/` para datas de calendário

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

Operadores <chrono>

operator+

Valor retornado

Exemplo: operator+

operator+ unário

Valor retornado

operator-

Valor retornado

Exemplo: operator-

operator- unário

Valor retornado

Exemplo: operator- unário

operator!=

Parâmetros

Valor retornado

operator*

Parâmetros

Valor retornado

operator<

Parâmetros

Valor retornado

operator<=

Parâmetros

Valor retornado

operator==

Parâmetros

Valor retornado

operator>

Parâmetros

Valor retornado

operator>=

Parâmetros

Valor retornado

operator<=>

Parâmetros

Valor retornado

Exemplo: operator<=>

operator<<

Parâmetros

Valor retornado

Comentários

Exemplo: operator<<

operator modulo

Parâmetros

Valor retornado

operator/ para duration

Parâmetros

Valor retornado

operator/ para datas do calendário

Parâmetros

Valor retornado

Exemplo: operator/ para datas de calendário

Comentários

Comentários

Recursos adicionais

Operadores `<chrono>`

`operator+`

Exemplo: `operator+`

`operator+` unário

`operator-`

Exemplo: `operator-`

`operator-` unário

Exemplo: `operator-` unário

`operator!=`

`operator*`

`operator<`

`operator<=`

`operator==`

`operator>`

`operator>=`

`operator<=>`

Exemplo: `operator<=>`

`operator<<`

Exemplo: `operator<<`

`operator modulo`

`operator/` para `duration`

`operator/` para datas do calendário

Exemplo: `operator/` para datas de calendário