<chrono>
Operadores
operator+
Operador de suma para los tipos siguientes:
day
duration
month
time_point
weekday
year
year_month
year_month_day
year_month_day_last
year_month_weekday
year_month_weekday_last
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
constexpr common_type_t<duration> operator+() const // C++20
Valor devuelto
Devuelve *this
operator-
Operador de resta para los tipos siguientes:
day
duration
month
time_point
weekday
year
year_month
year_month_day
year_month_day_last
year_month_weekday
year_month_weekday_last
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:
day
duration
month
month_day
month_day_last
time_point
time_zone_link
year
year_month
year_month_day_last
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:
day
file_time
gps_time
hh_mm_ss
local_time
local_info
month
month_day
month_day_last
month_weekday
month_weekday_last
sys_info
tai_time
utc_time
weekday
weekday_indexed
weekday_last
year
year_month
year_month_day
year_month_day_last
year_month_weekday
year_month_weekday_last
zoned_time
// 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