`<chrono>` operadores

`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 de retorno

1) Após a conversão Left e Right para o seu tipo comum, retorna um duration com uma contagem de tick igual à soma das contagens de tick convertidas.

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

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

5) Devolve o resultado de m+ms.count(). Se o resultado estiver fora do intervalo [1, 12], é reduzido o módulo 12 e, em seguida, +1.

6) Devolve o resultado da adição do número de dias e dias úteis ao weekday. O resultado será o módulo 7, portanto sempre na faixa [0,6]

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

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

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

10) Devoluções (ymdl.year() / ymdl.month() + dm) / last. Nota: O / usado aqui não é um operador de divisão. É o operador de data.

11) Devoluções ymdl + dm.

12) Devoluções {ymdl.year()+dy, ymdl.month_day_last()}

13) Devoluções ymwd + dm.count().

14-15) Devoluções {ymwd.year()+dy, ymwd.month(), ymwd.weekday_indexed()}.

16) Devoluções (ymwdl.year() / ymwdl.month() + dm) / ymwdl.weekday_last(). Nota: O / usado aqui não é um operador de divisão, mas o operador de data.

17) Devoluções: 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]

Unário `operator+`

Aplique unary plus aos seguintes tipos:

duration.

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

Valor de retorno

Devoluções *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 de retorno

1) Depois de converter as durações que estão sendo subtraídas para seu tipo comum, retorna um duration com uma contagem de ticks igual ao número de ticks em Right subtraído do número de ticks em Left.

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

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

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

5) Se m.ok() == true e ms.ok() == true, retorna o resultado de subtrair os valores de dois meses, ou subtrair o número de meses. O resultado estará no intervalo [1, 12]. Se o resultado for negativo, enrola-se. Por exemplo, subtraindo um mês de janeiro (month m1{1} - months{1}; resulta em 12 (dezembro).

6) Devolve a diferença em meses entre Left e Right

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

8) Devolve o número de dias entre dois dias úteis.

9) Devoluções year(int(y)-ys.count())

10) Devoluções years(int(y) - int(y2)). Subtraindo dois year valores 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) Devolve o resultado da subtração de meses ou anos de um year_month valor.

12) Devolve o resultado de subtrair meses anos de um year_month_day valor.

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

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

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

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

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

18) Devolve o resultado da subtração do número de anos do year_month_weekday_last valor. 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'; // 2020/May/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]

Unário `operator-`

Nega um duration.

constexpr common_type_t<duration> operator-() const;

Valor de retorno

Devolve uma cópia negada de *this

Exemplo: unário `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) Dois duration objetos não representam o mesmo número de ticks.
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
A esquerda duration ou time_point objeto.

Right
O direito duration ou time_point objeto.

Valor de retorno

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

`operator*`

Operador de multiplicação para duration objetos. Depois de converter o durations que está sendo multiplicado para seu tipo comum, retorna a duration com uma contagem de tick igual à multiplicação das contagens de tick 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 de retorno

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

1) A menos que is_convertible<Rep2, common_type<Rep1, Rep2>>seja mantida true, esta função não participa na resolução de sobrecarga. Para obter mais informações, consulte <type_traits>.

2) A menos que is_convertible<Rep1, common_type<Rep1, Rep2>>seja mantida true, esta função não participa na resolução de sobrecarga. Para obter mais informações, consulte <type_traits>.

`operator<`

1) Depois de converter o durations sendo comparado ao seu tipo comum, determina se o número de ticks for Left é menor do que para Right.

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

Parâmetros

Left
A esquerda duration ou time_point objeto.

Right
O direito duration ou time_point objeto.

Valor de retorno

1) Devolve true se o número de ticks for Left inferior ao número de ticks para Right. Caso contrário, a função retorna false.

2) Devolve true se Left precede.Right Caso contrário, retorna false.

`operator<=`

1) Depois de converter o durations sendo comparado ao seu tipo comum, determina se o número de ticks for Left é menor ou igual a Right.

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

Parâmetros

Left
A esquerda duration ou time_point objeto.

Right
O direito duration ou time_point objeto.

Valor de retorno

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

2) Devolve true se Left precede, ou é igual a, Right. Caso contrário, retorna false.

`operator==`

Determina se:

1) duration objetos representam intervalos de tempo que têm o mesmo comprimento.
2) time_point os objetos representam o mesmo ponto no tempo.
3) day os objetos representam o mesmo dia.
4) month os objetos representam o mesmo mês.
5) month_day os objetos representam o mesmo mês e dia.
6) month_day_last os objetos representam o mesmo mês.
7) month_weekday os objetos representam o mesmo mês e o nono dia da semana.
8) month_weekday_last os objetos representam o mesmo mês e o último dia da semana.
9) weekday os objetos representam o mesmo dia da semana.
10) weekday_last os objetos representam o mesmo último dia útil do mês.
11) weekday_indexed representam o mesmo índice de dias úteis.
12) year representam o mesmo ano.
13) year_month representam o mesmo ano e mês.
14) year_month_day representam o mesmo ano, mês e dia.
15) year_month_day_last representam o mesmo último dia do ano e do mês.
16) year_month_weekday representam o mesmo dia da semana, ano e mês.
17) year_month_weekday_last representam o mesmo último dia útil do mês, ano e mês.
18) time_zone_link têm o mesmo name. O target nome não é considerado.
19) zoned_time representam a mesma hora 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 para comparar, por exemplo, Left == Right

Right
O objeto certo para comparar.

Valor de retorno

1) Devolve true se o número de ticks para o tipo comum a Left e Right são iguais. Caso contrário, retorna false.
2) Devolve true se Left e Right representa o mesmo ponto no tempo. Caso contrário, retorna false.
3-17) Devolve true se Left e Right tem o mesmo valor. Caso contrário, retorna false.
18) Devolve true se Left.name() == Right.name(). Caso contrário, retorna false.
19) Devoluções true se Left.get_time_zone() == Right.get_time_zone() && Left.get_sys_time() == Right.get_sys_time();

`operator>`

1) Depois de converter o durations sendo comparado ao seu tipo comum, determina se o número de ticks for Left é maior do que para Right.

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

Parâmetros

Left
A esquerda duration ou time_point objeto.

Right
O direito duration ou time_point objeto.

Valor de retorno

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

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

`operator>=`

1) Depois de converter o durations sendo comparado ao seu tipo comum, determina se o número de ticks for Left é maior ou igual a Right.

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

Parâmetros

Left
A esquerda duration ou time_point objeto.

Right
O direito duration ou time_point objeto.

Valor de retorno

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

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

`operator<=>`

O operador da nave espacial, 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
O day, duration, month, , month_day, month_day_lasttime_point, time_zone_link, , year, year_month, , year_month_day, para year_month_day_last comparar.

Valor de retorno

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

Saída dos 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++ fornece especializações desse modelo de classe, com as definições de tipo string para elementos do tipo char, wstring, para wchar_t, u16string para char16_te u32string para char32_t.

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

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

d
A day saída.

hms
A hh_mm_ss saída.

li
A local_info saída.

m
A month saída.

md
A month_day saída.

mdl
A month_day_last saída.

mwd
A month_weekday saída.

mwdl
A month_weekday_last saída.

si
A sys_info saída.

t
O local_time, gps_time, tai_time, ou utc_time a saída.

TimeZonePtr
Um ponteiro para o time_zone armazenado no zoned_time.

wd
A weekday saída.

wdi
A weekday_indexed saída.

wdl
A weekday_last saída.

y
A year saída.

ym
A year_month saída.

ymd
A year_month_day saída.

ymdl
A year_month_day_last saída.

ymwd
A year_month_weekday saída.

ymwdl
A year_month_weekday_last saída.

zt
A zoned_time saída.

Valor de retorno

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

Observações

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

2) O hh_mm_ss valor é saída 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 osa , é saída. Por exemplo, Jan. Se !m.ok(), então " is not a valid month" é anexado à saída.

4) O nome abreviado do mês, usando a localidade associada osa , seguido da data, com um zero à esquerda se o resultado for um único dígito, é saída. Por exemplo, Jan/05. Se !md.ok(), então " is not a valid month" pode ser anexado à produção do mês, e "is not a valid day" pode ser anexado à 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 osa , seguido de /last. Por exemplo, Jan/last.

6) O nome abreviado do dia da semana, usando a localidade associada osa , seguido pelo nono dia da semana no mês que representa entre parênteses. Por exemplo, Mon[1].

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

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

9) O nome abreviado do dia da semana, usando a localidade associada osa , é saída, seguido pelo dia da semana do mês entre parênteses. Por exemplo, Mon[3]. Se !wd.ok(), então " is not a valid weekday" pode ser anexado à saída do dia da semana, e "is not a valid index" pode ser anexado à saída do índice do dia da semana.

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

11) O ano é acolchoado à 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" é anexado à saída.

12) A year_month saída é na forma yyy-mm-dd. Se ym.ok retorna false, então " is not a valid date" é anexado.

13) A year_month_day saída é na forma aaaa-mm-dd. Se ymd.ok retorna false, então " is not a valid date" é anexado.

14) A year_month_day_last saída é na forma aaaa/mês/último. Por exemplo, 2020/May/last.

15) A year_month_weekday saída é na forma aaaa/mês/dia da semana[índice]. Por exemplo, 1996/Jan/Wed[1]

16) A year_month_weekday_last saída é na forma aaaa/mês/dia da semana[último]. Por exemplo, 1996/Jan/Wed[last]

17) A tai_time saída é na forma aaaa-mm-dd hh:mm:ss.ssssssss. Por exemplo, 2021-08-13 23:23:08.4358666

18) A utc_time saída é na forma aaaa-mm-dd hh:mm:ss.ssssssss. Por exemplo, 2021-08-13 23:23:08.4358666

19) A gps_time saída é na forma aaaa-mm-dd hh:mm:ss.ssssssss. Por exemplo, 2021-08-13 23:23:08.4358666

20) A local_time saída é como o número de segundos desde a época do relógio. É saída 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 15:13, a saída é 1597792380.

21) Na implementação da Microsoft, a é saída como seus sys_infocampos , begin, end, offset, e save .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, a local_info é saída como aaaa-mm-dd hh:mm:ss.sssss. Por exemplo, 2021-09-17 13:55:59.6590120

23) A hora local no (obtido como zoned_time) é saída usando o formato aaaa-mm-dd fuso zt.get_local_time() horário hh:mm:ss. 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 restante após a divisão do dividendo pelo divisor.

Right
O objeto certo duration , o divisor.

Valor de retorno

1) Retorna um duration objeto cujo comprimento de intervalo é Dur modulo Div.

2) Devolve um valor que representa Left o Rightmódulo.

`operator/` para `duration`

Operador de divisão para duration objetos.

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
O objeto esquerdo duration .

Right
O objeto certo duration .

Valor de retorno

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

2) A razão entre os comprimentos dos intervalos de Left e Right.

A menos que is_convertible<Rep2, common_type<Rep1, Rep2>>seja true e Rep2 não seja uma instanciação do , o primeiro operador não participa da resolução de durationsobrecarga. Para obter mais informações, consulte <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
ano/mês/dia

Pode substituir o dia por:

last
weekday[n] para o nono dia do mês
weekday[last] para o último weekday dia do mês.

As datas parciais podem ser formadas da seguinte forma:

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

Números 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 tag vazio que indica o último item de uma sequência. 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 útil do mês especificado.

mwdl
O último dia útil do mês especificado.

wdi
Um índice de dias úteis (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 número inteiro ou como um yeararquivo .

ym
O ano e o mês.

Valor de retorno

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

Feedback

Esta página foi útil?

Last updated on 2025-11-07

Partilhar via

<chrono> operadores

operator+

Valor de retorno

Exemplo: operator+

Unário operator+

Valor de retorno

operator-

Valor de retorno

Exemplo: operator-

Unário operator-

Valor de retorno

Exemplo: unário operator-

operator!=

Parâmetros

Valor de retorno

operator*

Parâmetros

Valor de retorno

operator<

Parâmetros

Valor de retorno

operator<=

Parâmetros

Valor de retorno

operator==

Parâmetros

Valor de retorno

operator>

Parâmetros

Valor de retorno

operator>=

Parâmetros

Valor de retorno

operator<=>

Parâmetros

Valor de retorno

Exemplo: operator<=>

operator<<

Parâmetros

Valor de retorno

Observações

Exemplo: operator<<

operator modulo

Parâmetros

Valor de retorno

operator/ para duration

Parâmetros

Valor de retorno

operator/ para datas do calendário

Parâmetros

Valor de retorno

Exemplo: operator/ para datas do calendário

Feedback

Recursos adicionais

`<chrono>` operadores

`operator+`

Exemplo: `operator+`

Unário `operator+`

`operator-`

Exemplo: `operator-`

Unário `operator-`

Exemplo: unário `operator-`

`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 do calendário