`<chrono>` Operadores

Artículo
06/16/2023

`operator+`

Operador de suma para los tipos siguientes:

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 devuelto

1) Después de convertir Left y Right a su tipo común, devuelve un elemento duration con un contador igual a la suma de los contadores convertidos.

2-3) Devuelve un objeto time_point que representa un punto en el tiempo que está desplazado, según el intervalo Dur, con respecto al punto en el tiempo Time.

4) Devuelve el resultado de d+ds.count(). Si el resultado está fuera del intervalo [0, 255], no se especifica.

5) Devuelve el resultado de m+ms.count(). Si el resultado está fuera del intervalo [1, 12], se reduce el módulo en 12 y, luego, +1.

6) Devuelve el resultado de sumar el número de días y días de la semana a weekday. El resultado será un módulo 7, por lo que siempre estará en el intervalo [0,6].

7) Devuelve el resultado de sumar el año al número de años especificado.

8) Devuelve el resultado de sumar el número de meses y años al mes y año especificados.

9) Devuelve el resultado de sumar meses o años a year_month_day. Si ymd.month() es February y ymd.day() no está en el intervalo [1d, 28d], ok() puede devolver false para el resultado de la suma.

10) Devuelve (ymdl.year() / ymdl.month() + dm) / last. Nota: El elemento / que se usa aquí no es un operador de división. Es el operador de fecha.

11) Devuelve ymdl + dm.

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

13) Devuelve ymwd + dm.count().

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

16) Devuelve (ymwdl.year() / ymwdl.month() + dm) / ymwdl.weekday_last(). Nota: El elemento / que se usa aquí no es un operador de división, sino el operador de fecha.

17) Devuelve ymwdl + dy.

Ejemplo: `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+` unario

Aplique el signo más unario a los tipos siguientes:

duration.

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

Valor devuelto

Devuelve *this

`operator-`

Operador de resta para los tipos siguientes:

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 devuelto

1) Después de convertir las duraciones que se restan a su tipo común, devuelve un elemento duration con un contador igual al número de ciclos del elemento Right restado del número de ciclos del elemento Left.

2) Devuelve un objeto time_point que representa un punto en el tiempo que está desplazado, según la negación del intervalo de tiempo representado por Dur, con respecto al punto en el tiempo especificado por Time.

3) Devuelve un objeto duration que representa el intervalo de tiempo entre Left y Right.

4) Devuelve el resultado de d-ds.count(). Si el resultado está fuera del intervalo [0, 255], no se especifica.

5) Si m.ok() == true y ms.ok() == true, devuelve el resultado de restar los dos valores de mes o de restar el número de meses. El resultado estará en el intervalo [1, 12]. Si el resultado es negativo, se ajusta. Por ejemplo, al restar un mes de enero (month m1{1} - months{1};) se obtiene como resultado 12 (diciembre).

6) Devuelve la diferencia en meses entre Left y Right.

7) Si Left.ok() == true y Right.ok() == true, devuelve un objeto weekday en el intervalo [days{0}, days{6}].

8) Devuelve el número de días entre dos días de la semana.

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

10) Devuelve years(int(y) - int(y2)). Al restar dos valores year se obtiene como resultado un objeto std::chrono::years, que representa la diferencia en años entre y y y2. Por ejemplo, 2021y-2000y genera years(21).

11) Devuelve el resultado de restar meses o años de un valor year_month.

12) Devuelve el resultado de restar meses o años de un valor year_month_day.

13) Devuelve el resultado de restar el número de meses del valor year_month_day_last. Básicamente, ymdl-dm.

14) Devuelve el resultado de restar el número de años del valor year_month_day_last. Básicamente, ymdl-dy.

15) Devuelve el resultado de restar el número de meses del valor year_month_weekday. Básicamente, ymwd-dm.

16) Devuelve el resultado de restar el número de años del valor year_month_weekday. Básicamente, ymwd-dy.

17) Devuelve el resultado de restar el número de meses del valor year_month_weekday_last. Básicamente, ymwdl-dm.

18) Devuelve el resultado de restar el número de años del valor year_month_weekday_last. Básicamente, ymwdl-dy.

Ejemplo: `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-` unario

Niega un objeto duration.

constexpr common_type_t<duration> operator-() const;

Valor devuelto

Devuelve una copia negada de *this.

Ejemplo: `operator-` unario

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

1) Dos objetos duration no representan el mismo número de ciclos.
2) Dos time_point objetos no representan el mismo momento en el tiempo.

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
Objeto duration o time_point izquierdo.

Right
Objeto duration o time_point derecho.

Valor devuelto

1) Devuelve true si el número de ciclos del tipo común de Left y Right no son iguales. De lo contrario, devuelve false.
2) Devuelve true si los dos objetos time_point no representan el mismo punto en el tiempo. De lo contrario, devuelve false.

`operator*`

Operador de multiplicación para objetos duration. Después de convertir los objetos duration que se multiplican a su tipo común, devuelve un elemento duration con un contador igual a la multiplicación de los contadores convertidos.

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
Un objeto duration.

Mult
Valor entero.

Valor devuelto

Devuelve un objeto duration cuya longitud del intervalo es Mult multiplicada por la longitud de Dur.

1) A menos que is_convertible<Rep2, common_type<Rep1, Rep2>> sea true, esta función no participa en la resolución de sobrecargas. Para obtener más información, consulte <type_traits>.

2) A menos que is_convertible<Rep1, common_type<Rep1, Rep2>> sea true, esta función no participa en la resolución de sobrecargas. Para obtener más información, consulte <type_traits>.

`operator<`

1) Después de convertir los objetos duration que se comparan con su tipo común, determina si el número de ciclos de Left es menor que el de Right.

2) Determina si el punto en el tiempo desde la época de time_point de Left es menor que el tiempo desde la época de time_point de 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
Objeto duration o time_point izquierdo.

Right
Objeto duration o time_point derecho.

Valor devuelto

1) Devuelve true si el número de ciclos de Left es menor que el número de ciclos de Right. De lo contrario, la función devuelve false.

2) Devuelve true si Left precede a Right. De lo contrario, devuelve false.

`operator<=`

1) Después de convertir los objetos duration que se comparan con su tipo común, determina si el número de ciclos de Left es menor o igual que el de Right.

2) Determina si el punto en el tiempo desde la época de time_point de Left es menor o igual que el tiempo desde la época de time_point de 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
Objeto duration o time_point izquierdo.

Right
Objeto duration o time_point derecho.

Valor devuelto

1) Devuelve true si el número de ciclos de Left es menor o igual que el número de ciclos de Right. De lo contrario, la función devuelve false.

2) Devuelve true si Left precede o es igual a Right. De lo contrario, devuelve false.

`operator==`

Determina si:

1) Los objetos duration representan intervalos de tiempo que tienen la misma longitud.
2) Los objetos time_point representan el mismo punto en el tiempo.
3) Los objetos day representan el mismo día.
4) Los objetos month representan el mismo mes.
5) Los objetos month_day representan el mismo mes y día.
6) Los objetos month_day_last representan el mismo mes.
7) Los objetos month_weekday representan el mismo mes y número de día de la semana.
8) Los objetos month_weekday_last representan el mismo mes y último día de la semana.
9) Los objetos weekday representan el mismo día de la semana.
10) Los objetos weekday_last representan el mismo último día de la semana del mes.
11) Los objetos weekday_indexed representan el mismo índice de día de la semana.
12) Los objetos year representan el mismo año.
13) Los objetos year_month representan el mismo año y mes.
14) Los objetos year_month_day representan el mismo año, mes y día.
15) Los objetos year_month_day_last representan el mismo último día del año y mes.
16) Los objetos year_month_weekday representan el mismo día de la semana, año y mes.
17) Los objetos year_month_weekday_last representan el mismo último día de la semana del año y mes.
18) Los objetos time_zone_link tienen el mismo valor de name. No se tiene en cuenta el nombre target.
19) Los objetos zoned_time representan la misma hora y zona horaria.

// 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
El objeto izquierdo que se compara, por ejemplo, Left == Right.

Right
El objeto derecho que se compara.

Valor devuelto

1) Devuelve true si el número de ciclos del tipo común de Left y Right son iguales. De lo contrario, devuelve false.
2) Devuelve true si Left y Right representan el mismo punto en el tiempo. De lo contrario, devuelve false.
3-17) Devuelve true si Left y Right tienen el mismo valor. De lo contrario, devuelve false.
18) Devuelve true si Left.name() == Right.name(). De lo contrario, devuelve *false*.
19) Devuelve true si Left.get_time_zone() == _Right.get_time_zone() && Left.get_sys_time() == Right.get_sys_time();.

`operator>`

1) Después de convertir los objetos duration que se comparan con su tipo común, determina si el número de ciclos de Left es mayor que el de Right.

2) Determina si el punto en el tiempo desde la época de time_point de Left es mayor que el tiempo desde la época de time_point de 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
Objeto duration o time_point izquierdo.

Right
Objeto duration o time_point derecho.

Valor devuelto

1) Devuelve true si el número de ciclos de Left es mayor que el número de ciclos de Right. De lo contrario, la función devuelve false.

2) Devuelve true si Left aparece después de Right. De lo contrario, devuelve false.

`operator>=`

1) Después de convertir los objetos duration que se comparan con su tipo común, determina si el número de ciclos de Left es mayor o igual que el de Right.

2) Determina si el punto en el tiempo desde la época de time_point de Left es mayor o igual que el tiempo desde la época de time_point de 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
Objeto duration o time_point izquierdo.

Right
Objeto duration o time_point derecho.

Valor devuelto

1) Devuelve true si el número de ciclos de Left es mayor o igual que el número de ciclos de Right. De lo contrario, la función devuelve false.

2) Devuelve true si Left aparece después de Right o es igual a este. De lo contrario, devuelve false.

`operator<=>`

El operador de nave espacial, con operator==, sintetiza operadores para <, <=, >, >= y != para los tipos siguientes:

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
Los objetos day, duration, month, month_day, month_day_last, time_point, time_zone_link, year, year_month, year_month_day y year_month_day_last que se van a comparar.

Valor devuelto

1)
0 si Left == Right
< 0 si Left < Right
> 0 si 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()

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

Genera los tipos siguientes en un flujo:

// 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
Tipo de datos de un carácter único que se va a leer del flujo y almacenar en la cadena. La biblioteca estándar de C++ proporciona especializaciones de esta plantilla de clase, con las definiciones de tipo string para elementos de tipo char, wstring para wchar_t, u16string para char16_t y u32string para char32_t.

Traits
Describe los atributos CharT para la especialización basic_string y basic_istream.

os
Flujo de salida en el que se va a emitir el valor day.

d
day que se va a generar.

hms
hh_mm_ss que se va a generar.

li
local_info que se va a generar.

m
month que se va a generar.

md
month_day que se va a generar.

mdl
month_day_last que se va a generar.

mwd
month_weekday que se va a generar.

mwdl
month_weekday_last que se va a generar.

si
sys_info que se va a generar.

t
local_time, gps_time, tai_time o utc_time que se va a generar.

TimeZonePtr
Puntero al objeto time_zone almacenado en zoned_time.

wd
weekday que se va a generar.

wdi
weekday_indexed que se va a generar.

wdl
weekday_last que se va a generar.

y
year que se va a generar.

ym
year_month que se va a generar.

ymd
year_month_day que se va a generar.

ymdl
year_month_day_last que se va a generar.

ymwd
year_month_weekday que se va a generar.

ymwdl
year_month_weekday_last que se va a generar.

zt
zoned_time que se va a generar.

Valor devuelto

Flujo de salida que se pasó en os.

Comentarios

1) El valor day se genera como un número decimal, con un cero inicial si el resultado es un solo dígito. Si !d.ok(), se anexa "is not a valid day" a la salida.

2) El valor hh_mm_ss se genera como horas:minutos:segundos:milésimas de segundos. Por ejemplo, "00:00:05.721".

3) Se genera el nombre abreviado del mes con la configuración regional asociada a os. Por ejemplo, Jan. Si !m.ok(), se anexa " is not a valid month" a la salida.

4) Se genera el nombre abreviado del mes con la configuración regional asociada a os, seguido de la fecha, con un cero inicial si el resultado es un solo dígito. Por ejemplo, Jan/05. Si !md.ok(), puede que se anexe " is not a valid month" a la salida del mes y "is not a valid day" a la salida del día. Por ejemplo, 204 is not a valid month/204 is not a valid day.

5) Nombre abreviado del mes con la configuración regional asociada a os, seguido de /last. Por ejemplo, Jan/last.

6) Nombre abreviado del día de la semana con la configuración regional asociada a os, seguido del número de día de la semana del mes que representa entre corchetes. Por ejemplo, Mon[1].

7) Nombre abreviado del día de la semana con la configuración regional asociada a os, seguido del último día de la semana del mes que representa entre corchetes. Por ejemplo, Jan/Mon[last].

8) Se genera el nombre abreviado del día de la semana con la configuración regional asociada a os. Si !wd.ok(), se anexa " is not a valid weekday" a la salida.

9) Se genera el nombre abreviado del día de la semana con la configuración regional asociada a os, seguido del día de la semana del mes entre corchetes. Por ejemplo, Mon[3]. Si !wd.ok(), puede que se anexe " is not a valid weekday" al día de la salida de la semana y "is not a valid index" a la salida del índice de día de la semana.

10) Se genera el último día de la semana de un mes con la configuración regional asociada a os, seguido de [last] y de la fecha. Por ejemplo, Tue[last] 2019-10-29. Si !wd.ok(), puede que se anexe " is not a valid weekday" al día de la salida de la semana y "is not a valid index" a la salida del índice de día de la semana.

11) El año se rellena a la izquierda con entre 0 (cero) y cuatro dígitos si el resultado es menor que eso. Si !y.ok(), se anexa " is not a valid year" a la salida.

12) Se genera year_month con el formato aaaa-mm-dd. Si ym.ok devuelve false, se anexa " is not a valid date".

13) Se genera year_month_day con el formato aaaa-mm-dd. Si ymd.ok devuelve false, se anexa " is not a valid date".

14) Se genera year_month_day_last con el formato aaaa/mes/último. Por ejemplo, 2020/May/last.

15) Se genera year_month_weekday con el formato aaaa/mes/día de la semana[índice]. Por ejemplo: 1996/Jan/Wed[1]

16) Se genera year_month_weekday_last con el formato aaaa/mes/día de la semana[último]. Por ejemplo: 1996/Jan/Wed[last]

17) Se genera tai_time con el formato aaaa-mm-dd hh:mm:ss.sssssss. Por ejemplo: 2021-08-13 23:23:08.4358666

18) Se genera utc_time con el formato aaaa-mm-dd hh:mm:ss.sssssss. Por ejemplo: 2021-08-13 23:23:08.4358666

19) Se genera gps_time con el formato aaaa-mm-dd hh:mm:ss.sssssss. Por ejemplo: 2021-08-13 23:23:08.4358666

20) Se genera local_time como el número de segundos desde la época del reloj. Se genera como si fuese os << std::chrono::sys_time<Duration>(some_local_time.time_since_epoch());. Por ejemplo, si some_local_time es el 18 de agosto de 2021 a las 15:13, la salida es 1597792380.

21) En la implementación de Microsoft, se genera sys_info como sus campos begin, end, offset, save y abbrev. Por ejemplo: begin: 2021-03-14 10:00:00, end: 2021-11-07 09:00:00, offset: -25200s, save: 60min, abbrev: PDT

22) En la implementación de Microsoft, se genera local_info como aaaa-mm-dd hh:mm::ss.sssss. Por ejemplo: 2021-09-17 13:55:59.6590120

23) Se genera la hora local de zoned_time (obtenida como zt.get_local_time()) con el formato aaaa-mm-dd hh:mm:ss zona horaria. Por ejemplo: 2021-09-15 10:45:00 GMT-6

Ejemplo: `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 operaciones de módulo en 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
Un objeto duration.

Div
Valor entero.

Left
Dividendo. El módulo es el resto después de dividir el dividendo por el divisor.

Right
Objeto duration derecho (el divisor).

Valor devuelto

1) Devuelve un objeto duration cuya longitud del intervalo es el módulo Div de Dur.

2) Devuelve un valor que representa el módulo Left de Right.

`operator/` para `duration`

Operador de división 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
Un objeto duration.

Div
Valor entero.

Left\w Objeto duration izquierdo.

Right
Objeto duration derecho.

Valor devuelto

1) Un objeto de duración cuya longitud del intervalo es la longitud de Dur dividida por el valor Div.

2) Proporción de las longitudes de intervalo de Left y Right.

A menos que is_convertible<Rep2, common_type<Rep1, Rep2>> sea true, y Rep2 no sea una creación de instancia de duration, el primer operador no participa en la resolución de sobrecargas. Para obtener más información, consulte <type_traits>.

`operator/` para fechas de calendario

Proporciona sintaxis para crear fechas de calendario con los formatos siguientes:

mes/día/año
día/mes/año
año/mes/día

Puede reemplazar el día por:

last
weekday[n] para el número de día del mes
weekday[last] para el último weekday del mes

Las fechas parciales se pueden formar de la manera siguiente:

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

Pueden usarse enteros, siempre y cuando la interpretación no sea ambigua.

/////////  returns year_month

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

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

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

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

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

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

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

/////////  returns month_day_last

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

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

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

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

/////////  returns month_weekday

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

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

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

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

/////////  returns month_weekday_last

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

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

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

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

/////////  returns year_month_day

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

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

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

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

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

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

/////////  returns year_month_day_last

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

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

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

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

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

/////////  returns year_month_weekday

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

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

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

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

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

/////////  returns year_month_weekday_last

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

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

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

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

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

Parámetros

d
Día. Se proporciona como un entero en el intervalo [1,31], o como day.

lastspec
Tipo de etiqueta vacía que indica el último elemento de una secuencia. Por ejemplo, 2021y/May/last es el último día de mayo de 2021.

m
El mes. Se proporciona como un entero en el intervalo [1,12], o como month.

md
Mes y día.

mdl
Último día del mes especificado.

mwd
Número de día de la semana del mes especificado.

mwdl
Último día de la semana del mes especificado.

wdi
Índice de día de la semana (weekday_indexed). Por ejemplo, weekday_indexed(Monday, 1) es el primer lunes de un mes.

wdl
Último día laborable de un mes. Por ejemplo, Monday[last] es el último lunes de un mes.

y
El año. Se proporciona como un entero o como year.

ym
Año y mes.

Valor devuelto

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

Ejemplo: `operator/` para fechas del calendario

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

using namespace std::chrono;

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

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

    return 0;
}

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

Compartir a través de

<chrono> Operadores

operator+

Valor devuelto

Ejemplo: operator+

operator+ unario

Valor devuelto

operator-

Valor devuelto

Ejemplo: operator-

operator- unario

Valor devuelto

Ejemplo: operator- unario

operator!=

Parámetros

Valor devuelto

operator*

Parámetros

Valor devuelto

operator<

Parámetros

Valor devuelto

operator<=

Parámetros

Valor devuelto

operator==

Parámetros

Valor devuelto

operator>

Parámetros

Valor devuelto

operator>=

Parámetros

Valor devuelto

operator<=>

Parámetros

Valor devuelto

Ejemplo: operator<=>

operator<<

Parámetros

Valor devuelto

Comentarios

Ejemplo: operator<<

operator modulo

Parámetros

Valor devuelto

operator/ para duration

Parámetros

Valor devuelto

operator/ para fechas de calendario

Parámetros

Valor devuelto

Ejemplo: operator/ para fechas del calendario

Comentarios

Recursos adicionales

`<chrono>` Operadores

`operator+`

Ejemplo: `operator+`

`operator+` unario

`operator-`

Ejemplo: `operator-`

`operator-` unario

Ejemplo: `operator-` unario

`operator!=`

`operator*`

`operator<`

`operator<=`

`operator==`

`operator>`

`operator>=`

`operator<=>`

Ejemplo: `operator<=>`

`operator<<`

Ejemplo: `operator<<`

`operator modulo`

`operator/` para `duration`

`operator/` para fechas de calendario

Ejemplo: `operator/` para fechas del calendario