`<chrono>`, opérateurs

Article
10/12/2023

`operator+`

Opérateur d’ajout pour les types suivants :

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

Valeur retournée

1) Après la conversion Left et Right le type commun, retourne un duration nombre de graduations égal à la somme des nombres de cycles convertis.

2-3) Retourne un time_point objet qui représente un point dans le temps déplacé par l’intervalle Dur du point dans le temps Time.

4) Retourne le résultat de d+ds.count(). Si le résultat est hors de la plage [0, 255], le résultat n’est pas spécifié.

5) Retourne le résultat de m+ms.count(). Si le résultat est hors de la plage [1, 12], il est réduit modulo 12, puis +1.

6) Retourne le résultat de l’ajout du nombre de jours et de jours de la semaine au weekday. Le résultat sera modulo 7, donc toujours dans la plage [0,6]

7) Retourne le résultat de l’ajout de l’année au nombre spécifié d’années.

8) Retourne le résultat de l’ajout du nombre de mois et d’années au mois et à l’année spécifiés.

9) Retourne le résultat de l’ajout de mois ou d’années à un year_month_day. Si ymd.month() elle ymd.day() n’est February pas comprise dans la plage [1d, 28d], ok() peut retourner false pour le résultat de l’ajout.

10) Renvoie (ymdl.year() / ymdl.month() + dm) / last. Remarque : L’opérateur / de division utilisé ici n’est pas un opérateur de division. Il s’agit de l’opérateur date.

11) Renvoie ymdl + dm.

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

13) Renvoie ymwd + dm.count().

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

16) Renvoie (ymwdl.year() / ymwdl.month() + dm) / ymwdl.weekday_last(). Remarque : l’opérateur / de division utilisé ici n’est pas un opérateur de division, mais l’opérateur de date.

17) Retourne : ymwdl + dy

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

Unaire `operator+`

Appliquez unaire plus aux types suivants :

duration.

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

Valeur retournée

Retourne *this.

`operator-`

Opérateur de soustraction pour les types suivants :

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

Valeur retournée

1) Après avoir converti les durées soustraites à leur type commun, retourne un duration nombre de graduations égal au nombre de graduations Right soustraites du nombre de graduations en Left.

2) Renvoie un time_point point dans le temps qui est déplacé par la négation de l’intervalle de temps représenté par Dur, à partir du point dans le temps spécifié par Time.

3) Renvoie un duration objet qui représente l’intervalle de temps entre Left et Right.

4) Retourne le résultat de d-ds.count(). Si le résultat est hors de la plage [0, 255], le résultat n’est pas spécifié.

5) Si m.ok() == true et ms.ok() == true, retourne le résultat de la soustraction des deux valeurs du mois ou de la soustraction du nombre de mois. Le résultat sera dans la plage [1, 12]. Si le résultat est négatif, il s’encapsule. Par exemple, soustraction d’un mois à partir de janvier (month m1{1} - months{1}; aboutit au 12 (décembre).

6) Retourne la différence en mois entre Left et Right

7) Si Left.ok() == true et Right.ok() == true, retourne une weekday valeur dans la plage [days{0}, days{6}].

8) Retourne le nombre de jours entre deux jours.

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

10) Renvoie years(int(y) - int(y2)). La soustraction de deux year valeurs entraîne une std::chrono::yearsdifférence dans les années entre y et y2. Par exemple, 2021y-2000y produit years(21).

11) Retourne le résultat de la soustraction de mois ou d’années d’une year_month valeur.

12) Retourne le résultat de la soustraction des mois d’une year_month_day valeur.

13) Retourne le résultat de la soustraction du nombre de mois de la year_month_day_last valeur. Essentiellement : ymdl-dm.

14) Retourne le résultat de la soustraction du nombre d’années de la year_month_day_last valeur. Essentiellement : ymdl-dy.

15) Retourne le résultat de la soustraction du nombre de mois de la year_month_weekday valeur. Essentiellement : ymwd-dm.

16) Retourne le résultat de la soustraction du nombre d’années de la year_month_weekday valeur. Essentiellement : ymwd-dy.

17) Retourne le résultat de la soustraction du nombre de mois de la year_month_weekday_last valeur. Essentiellement : ymwdl-dm.

18) Retourne le résultat de la soustraction du nombre d’années de la year_month_weekday_last valeur. Essentiellement : ymwdl-dy.

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

Unaire `operator-`

Annule un duration.

constexpr common_type_t<duration> operator-() const;

Valeur retournée

Retourne une copie négation de *this

Exemple : unaire `operator-`

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

using namespace std::chrono;

int main()
{
   duration<int, std::milli> milliseconds(120);
   std::cout << -milliseconds << '\n';
   return 0;
}

-120ms

`operator!=`

Détermine si :

1) Deux duration objets ne représentent pas le même nombre de graduations.
2) Deux time_point objets ne représentent pas le même point dans le temps.

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

Paramètres

Left
Objet duration ou time_point gauche.

Right
Objet duration ou time_point droit.

Valeur retournée

1) Retourne true si le nombre de graduations pour le type commun et Left Right ne sont pas égaux. Sinon, retourne false.
2) Retourne true si les deux time_point objets ne représentent pas le même point dans le temps. Sinon, retourne false.

`operator*`

Opérateur de multiplication pour les objets duration. Après avoir converti les durationcaractères multipliés en leur type commun, retourne un duration nombre de graduations égal à la multiplication des nombres de cycles convertis.

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

Paramètres

Dur
Objet duration.

Mult
Valeur intégrale.

Valeur retournée

Renvoie un duration objet dont la longueur d’intervalle est Mult multipliée par la longueur de Dur.

1) Sauf si is_convertible<Rep2, common_type<Rep1, Rep2>>elle est conservée true, cette fonction ne participe pas à la résolution de surcharge. Pour plus d’informations, consultez <type_traits>.

2) Sauf si is_convertible<Rep1, common_type<Rep1, Rep2>>elle est conservée true, cette fonction ne participe pas à la résolution de surcharge. Pour plus d’informations, consultez <type_traits>.

`operator<`

1) Après avoir converti les durations en cours par rapport à leur type commun, détermine si le nombre de graduations pour Left est inférieur à celui pour Right.

2) Détermine si le point dans le temps depuis l’époque de l’époque Lefttime_point est inférieur à l’heure depuis l’époque de l’époque time_point Righten .

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

Paramètres

Left
Objet duration ou time_point gauche.

Right
Objet duration ou time_point droit.

Valeur retournée

1) Renvoie true si le nombre de graduations pour Left est inférieur au nombre de graduations pour Right. Sinon, la fonction retourne false.

2) Retourne true si Left précède Right. Sinon, retourne false.

`operator<=`

1) Après avoir converti les durations en cours par rapport à leur type commun, détermine si le nombre de graduations pour Left est inférieur ou identique à Right.

2) Détermine si le point dans le temps depuis l’époque de l’époque Lefttime_point est inférieur ou égal à l’heure depuis l’époque de l’in time_point 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);

Paramètres

Left
Objet duration ou time_point gauche.

Right
Objet duration ou time_point droit.

Valeur retournée

1) Retourne true si le nombre de graduations pour Left est inférieur ou égal au nombre de graduations pour Right. Sinon, la fonction retourne false.

2) Retourne true si Left précède, ou est égal à , Right. Sinon, retourne false.

`operator==`

Détermine si :

1) duration les objets représentent des intervalles de temps qui ont la même longueur.
2) time_point les objets représentent le même point dans le temps.
3) day les objets représentent le même jour.
4) month les objets représentent le même mois.
5) month_day les objets représentent le même mois et le même jour.
6) month_day_last les objets représentent le même mois.
7) month_weekday les objets représentent le même mois et le nième jour de semaine.
8) month_weekday_last les objets représentent le même mois et le dernier jour de la semaine.
9) weekday les objets représentent le même jour de la semaine.
10) weekday_last les objets représentent le même dernier jour de semaine du mois.
11) weekday_indexed représentent le même index de jour de semaine.
12) year représentent la même année.
13) year_month représentent la même année et le même mois.
14) year_month_day représentent la même année, le mois et le jour.
15) year_month_day_last représentent le même jour de l’année et du mois.
16) year_month_weekday représentent le même jour de la semaine, l’année et le mois.
17) year_month_weekday_last représentent le même dernier jour de semaine du mois, de l’année et du mois.
18) time_zone_link ont le même name. Le target nom n’est pas pris en compte.
19) zoned_time représentent le même fuseau horaire et le même fuseau horaire.

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

Paramètres

Left
Objet gauche à comparer, par exemple, Left == Right

Right
Objet de droite à comparer.

Valeur retournée

1) Retourne true si le nombre de graduations pour le type commun et Left Right est égal. Sinon, retourne false.
2) Retourne true si Left et Right représente le même point dans le temps. Sinon, retourne false.
3-17) Retourne true si Left et Right ont la même valeur. Sinon, retourne false.
18) Retourne true si Left.name() == Right.name(). Sinon, retourne *false*.
19) Retourne true si Left.get_time_zone() == _Right.get_time_zone() && Left.get_sys_time() == Right.get_sys_time();

`operator>`

1) Après la conversion des durations en cours par rapport à leur type commun, détermine si le nombre de graduations pour Left est supérieur à celui de Right.

2) Détermine si le point dans le temps depuis l’époque de l’époque Lefttime_point est supérieur à l’heure depuis l’époque de l’époque time_point Righten .

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

Paramètres

Left
Objet duration ou time_point gauche.

Right
Objet duration ou time_point droit.

Valeur retournée

1) Retourne true si le nombre de graduations pour Left est supérieur au nombre de graduations pour Right. Sinon, la fonction retourne false.

2) Retourne true si Left vient après Right. Sinon, retourne false.

`operator>=`

1) Après avoir converti les durations en cours par rapport à leur type commun, détermine si le nombre de graduations pour Left est supérieur ou égal à Right.

2) Détermine si le point dans le temps depuis l’époque de l’époque Lefttime_point est supérieur ou égal à l’heure depuis l’époque de l’in time_point 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);

Paramètres

Left
Objet duration ou time_point gauche.

Right
Objet duration ou time_point droit.

Valeur retournée

1) Retourne true si le nombre de graduations pour Left est supérieur ou égal au nombre de graduations pour Right. Sinon, la fonction retourne false.

2) Retourne true si Left vient après, ou est égal à, Right. Sinon, retourne false.

`operator<=>`

L’opérateur de vaisseau spatial, avec operator==, synthétise les opérateurs pour <, <=>, , >=et != pour les types suivants :

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;

Paramètres

Left, Right
The day, durationtime_pointmonth_day_lastmonth_daymonthyearyear_monthtime_zone_link, , year_month_dayto year_month_day_last compare.

Valeur retournée

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

2)
Équivalent à : Left.month() <=> Right.month()

3)
Équivalent à :

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

4)
Équivalent à :

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

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

Affichez les types suivants dans un flux :

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

Paramètres

CharT
Type de données d’un caractère unique à lire à partir du flux et stocké dans la chaîne. La bibliothèque standard C++ fournit des spécialisations de ce modèle de classe, avec les définitions string de type pour les éléments de type char, wstringpour , pour wchar_t, u16string pour , pour char16_tet u32string pour char32_t.

Traits
Décrit CharT les attributs pour la spécialisation et basic_istream la basic_string spécialisation.

os
Flux de sortie dans qui émettre la day valeur.

d
À day générer.

hms
À hh_mm_ss générer.

li
À local_info générer.

m
À month générer.

md
À month_day générer.

mdl
À month_day_last générer.

mwd
À month_weekday générer.

mwdl
À month_weekday_last générer.

si
À sys_info générer.

t
Le local_time, gps_time, tai_timeou utc_time pour la sortie.

TimeZonePtr
Pointeur vers le time_zone stocké dans le zoned_time.

wd
À weekday générer.

wdi
À weekday_indexed générer.

wdl
À weekday_last générer.

y
À year générer.

ym
À year_month générer.

ymd
À year_month_day générer.

ymdl
À year_month_day_last générer.

ymwd
À year_month_weekday générer.

ymwdl
À year_month_weekday_last générer.

zt
À zoned_time générer.

Valeur retournée

Flux de sortie que vous avez passé, os

Notes

1) La day valeur est sortie sous la forme d’un nombre décimal, avec un zéro non significatif si le résultat serait un chiffre unique. Si !d.ok(), alors « n’est pas un jour valide » est ajouté à la sortie.

2) La hh_mm_ss valeur est sortie sous forme d’heures :minutes :secondes :millièmes de secondes. Par exemple, « "00:00:05.721

3) Le nom du mois abrégé, en utilisant les paramètres régionaux associés à os, est la sortie. Par exemple : Jan. Si !m.ok(), est " is not a valid month" ajouté à la sortie.

4) Nom du mois abrégé, en utilisant les paramètres régionaux associés osà la date, suivi de la date, avec un zéro non significatif si le résultat serait un chiffre unique, est la sortie. Par exemple : Jan/05. Si !md.ok(), peut " is not a valid month" être ajouté à la sortie du mois et "is not a valid day" peut être ajouté à la sortie du jour. Par exemple : 204 is not a valid month/204 is not a valid day.

5) Nom du mois abrégé, en utilisant les paramètres régionaux associés osà , suivis par /last. Par exemple : Jan/last.

6) Nom abrégé de la semaine, en utilisant les paramètres régionaux associés osà , suivi du nième jour de la semaine dans le mois, il représente entre crochets. Par exemple : Mon[1].

7) Nom abrégé de la semaine, en utilisant les paramètres régionaux associés osà , suivi du dernier jour de la semaine dans le mois, il représente entre crochets. Par exemple : Jan/Mon[last].

8) Le nom abrégé de la semaine, en utilisant les paramètres régionaux associés osà , est la sortie. Si !wd.ok(), est " is not a valid weekday" ajouté à la sortie.

9) Le nom abrégé de la semaine, en utilisant les paramètres régionaux associés à os, est la sortie, suivie du jour de la semaine du mois entre crochets. Par exemple : Mon[3]. Si !wd.ok(), peut " is not a valid weekday" être ajouté au jour de la sortie de la semaine et "is not a valid index" peut être ajouté à la sortie de l’index de la semaine.

10) Le dernier jour de semaine d’un mois, à l’aide des paramètres régionaux associés osà , est la sortie, suivie de [last]la date. Par exemple : Tue[last] 2019-10-29. Si !wd.ok(), peut " is not a valid weekday" être ajouté au jour de la sortie de la semaine et "is not a valid index" peut être ajouté à la sortie de l’index de la semaine.

11) L’année est à gauche avec 0 (zéro) à quatre chiffres si le résultat serait inférieur à celui-ci. Si !y.ok(), est " is not a valid year" ajouté à la sortie.

12) Sortie year_month sous forme aaaa-mm-jj. Si ym.ok cette propriété est retournée false, elle " is not a valid date" est ajoutée.

13) Sortie year_month_day sous forme aaaa-mm-jj. Si ymd.ok cette propriété est retournée false, elle " is not a valid date" est ajoutée.

14) La year_month_day_last sortie est sous forme aaaa/mois/dernier. Par exemple : 2020/May/last.

15) Sortie year_month_weekday sous forme aaaa/mois/semaine[index]. Par exemple, 1996/Jan/Wed[1]

16) Sortie year_month_weekday_last sous forme aaaa/mois/semaine[dernier]. Par exemple, 1996/Jan/Wed[last]

17) La tai_time sortie est sous forme aaaa-mm-jj hh :mm :sss.ssssssss. Par exemple, 2021-08-13 23:23:08.4358666

18) Sortie utc_time sous forme aaaa-mm-jj hh :mm :sss.ssssss. Par exemple, 2021-08-13 23:23:08.4358666

19) La gps_time sortie est sous forme aaaa-mm-jj hh :mm :sss.ssssssss. Par exemple, 2021-08-13 23:23:08.4358666

20) La local_time sortie est le nombre de secondes depuis l’époque de l’horloge. Il s’agit d’une sortie comme si .os << std::chrono::sys_time<Duration>(some_local_time.time_since_epoch()); Par exemple, si some_local_time c’est le 18 août 2021 13h13, la sortie est 1597792380.

21) Dans l’implémentation de Microsoft, une sys_info sortie est son begin, , end, offsetsaveet abbrev des champs. Par exemple : begin: 2021-03-14 10:00:00, end: 2021-11-07 09:00:00, offset: -25200s, save: 60min, abbrev: PDT

22) Dans l’implémentation de Microsoft, une local_info sortie est en tant que aaaa-mm-dd hh :mm ::ssss. Par exemple, 2021-09-17 13:55:59.6590120

23) L’heure locale dans le zoned_time (obtenu en tant que zt.get_local_time()) est la sortie à l’aide du fuseau horaire aaaa-mm-jj hh :mm :ss. Par exemple, 2021-09-15 10:45:00 GMT-6

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

Opérateur pour les opérations modulo sur 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);

Paramètres

Dur
Objet duration.

Div
Valeur intégrale.

Left
Dividende. Le modulo est le reste après avoir divisé le dividende par le diviseur.

Right
Objet droit duration , diviseur.

Valeur retournée

1) Renvoie un duration objet dont la longueur d’intervalle est Dur modulo Div.

2) Retourne une valeur qui représente Left modulo Right.

`operator/` pour `duration`

Opérateur de division pour les objets 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);

Paramètres

Dur
Objet duration.

Div
Valeur intégrale.

Left\w Objet gauche duration .

Right
Objet droit duration.

Valeur retournée

1) Objet de durée dont la longueur d’intervalle est la longueur de Dur la valeur Div.

2) Rapport des longueurs d’intervalle de Left et Right.

Sauf si is_convertible<Rep2, common_type<Rep1, Rep2>>elle a la valeur true et Rep2 n’est pas une instanciation de duration, le premier opérateur ne participe pas à la résolution de surcharge. Pour plus d’informations, consultez <type_traits>.

`operator/` pour les dates de calendrier

Fournit une syntaxe pour créer des dates de calendrier dans les formulaires suivants :

mois/jour/année
jour/mois/année
année/mois/jour

Vous pouvez remplacer le jour par :

last
weekday[n] pour le nième jour du mois
weekday[last] pour le dernier weekday du mois.

Les dates partielles peuvent être formées comme suit :

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

Les entiers peuvent être utilisés tant que l’interprétation n’est pas ambiguë.

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

Paramètres

d
Le jour. Fourni sous la forme d’un entier dans la plage [1,31], ou en tant que day.

lastspec
Type d’étiquette vide qui indique le dernier élément dans la séquence de s. Par exemple, 2021y/May/last c’est le dernier jour de mai 2021.

m
Mois. Fourni sous la forme d’un entier dans la plage [1,12], ou en tant que month.

md
Le mois et le jour.

mdl
Dernier jour du mois spécifié.

mwd
N-ième jour de semaine du mois spécifié.

mwdl
Dernier jour de semaine du mois spécifié.

wdi
Index de la semaine (weekday_indexed). Par exemple, weekday_indexed(Monday, 1) est le premier lundi d’un mois.

wdl
Le dernier jour de semaine d’un mois. Par exemple, Monday[last] c’est le dernier lundi d’un mois.

y
Année. Fourni sous forme d’entier, ou en tant que year.

ym
Année et mois.

Valeur retournée

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

Exemple : `operator/` pour les dates de calendrier

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

Partager via

<chrono>, opérateurs

operator+

Valeur retournée

Exemple : operator+

Unaire operator+

Valeur retournée

operator-

Valeur retournée

Exemple : operator-

Unaire operator-

Valeur retournée

Exemple : unaire operator-

operator!=

Paramètres

Valeur retournée

operator*

Paramètres

Valeur retournée

operator<

Paramètres

Valeur retournée

operator<=

Paramètres

Valeur retournée

operator==

Paramètres

Valeur retournée

operator>

Paramètres

Valeur retournée

operator>=

Paramètres

Valeur retournée

operator<=>

Paramètres

Valeur retournée

Exemple : operator<=>

operator<<

Paramètres

Valeur retournée

Notes

Exemple : operator<<

operator modulo

Paramètres

Valeur retournée

operator/ pour duration

Paramètres

Valeur retournée

operator/ pour les dates de calendrier

Paramètres

Valeur retournée

Exemple : operator/ pour les dates de calendrier

Commentaires

Ressources supplémentaires

`<chrono>`, opérateurs

`operator+`

Exemple : `operator+`

Unaire `operator+`

`operator-`

Exemple : `operator-`

Unaire `operator-`

Exemple : unaire `operator-`

`operator!=`

`operator*`

`operator<`

`operator<=`

`operator==`

`operator>`

`operator>=`

`operator<=>`

Exemple : `operator<=>`

`operator<<`

Exemple : `operator<<`

`operator modulo`

`operator/` pour `duration`

`operator/` pour les dates de calendrier

Exemple : `operator/` pour les dates de calendrier