`<chrono>` operatörer

2025-05-28

`operator+`

Additionsoperator för följande typer:

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

Returvärde

1) När du har konverterat Left och Right till deras gemensamma typ returnerar en duration med ett tickantal som är lika med summan av de konverterade tickantalen.

2-3) Returnera ett time_point objekt som representerar en tidpunkt som förskjuts av intervallet Dur från tidpunkten Time.

4) Returnerar resultatet av d+ds.count(). Om resultatet ligger utom intervallet [0, 255] är resultatet ospecificerat.

5) Returnerar resultatet av m+ms.count(). Om resultatet ligger utom intervallet [1, 12] minskas modulo 12 och sedan +1.

6) Returnerar resultatet av att lägga till antalet dagar och vardagar i weekday. Resultatet blir modulo 7, så alltid i intervallet [0,6]

7) Returnerar resultatet av att lägga till året till det angivna antalet år.

8) Returnerar resultatet av att lägga till antalet månader och år till den angivna månaden och året.

9) Returnerar resultatet av att lägga till månader eller år till en year_month_day. Om ymd.month() är February och ymd.day() inte finns i intervallet [1d, 28d], ok() kan returnera false för resultatet av tillägget.

10) Returnerar (ymdl.year() / ymdl.month() + dm) / last. Obs! Den / som används här är inte en divisionsoperator. Det är datumoperatorn.

11) Returnerar ymdl + dm.

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

13) Returnerar ymwd + dm.count().

14–15) Returnerar {ymwd.year()+dy, ymwd.month(), ymwd.weekday_indexed()}.

16) Returnerar (ymwdl.year() / ymwdl.month() + dm) / ymwdl.weekday_last(). Obs! Den / som används här är inte en divisionsoperator utan datumoperatorn.

17) Returnerar: ymwdl + dy

Exempel: `operator+`

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

using namespace std::chrono;

int main()
{
    // day
    day d{1};
    std::cout << d + days(2) << '\n'; // 03

    // month
    month m{11};
    std::cout << m + months(3)<< '\n'; // Feb

    // weekday
    weekday wd = Thursday;
    std::cout << wd + days(1) << '\n'; // Fri

    // year_month_day_last
    year_month_day_last ymdl{June / last / 2021};
    std::cout << ymdl + years{1} + months{1} << '\n'; // 2022/Jul/last

    // year_month_weekday
    year_month_weekday ymw{ year(1997) / January / Wednesday[1] };
    std::cout << ymw + months{1} << '\n'; // 1997/Feb/Wed[1]
    std::cout << ymw + years{1} << '\n'; // 1998/Jan/Wed[1]

    // year_month_weekday_last
    year_month_weekday_last ymwl{ year(1997) / January / Wednesday[last] };
    std::cout << ymwl + months{ 1 } << '\n'; // 1997/Feb/Wed[last]
    std::cout << ymwl + years{ 1 } << '\n'; // 1998/Jan/Wed[last]

    return 0;
}

03
Feb
Fri
2022/Jul/last
1997/Feb/Wed[1]
1998/Jan/Wed[1]
1997/Feb/Wed[last]
1998/Jan/Wed[last]

Unär `operator+`

Använd unary plus på följande typer:

duration.

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

Returvärde

Returnerar *this

`operator-`

Subtraktionsoperator för följande typer:

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

Returvärde

1) När du har konverterat varaktigheterna som subtraheras till deras gemensamma typ returnerar ett duration med ett tickantal som är lika med antalet tick i Right subtraherat från antalet tick i Left.

2) Returnerar en time_point som representerar en tidpunkt som förskjuts av negationen av tidsintervallet som representeras av Dur, från den tidpunkt som anges av Time.

3) Returnerar ett duration objekt som representerar tidsintervallet mellan Left och Right.

4) Returnerar resultatet av d-ds.count(). Om resultatet ligger utom intervallet [0, 255] är resultatet ospecificerat.

5) Om m.ok() == true och ms.ok() == true, returnerar resultatet av att subtrahera de två månadsvärdena eller subtrahera antalet månader. Resultatet kommer att ligga i intervallet [1, 12]. Om resultatet är negativt omsluter det. Du kan till exempel subtrahera en månad från januari (month m1{1} - months{1}; resulterar i 12 (december).

6) Returnerar skillnaden i månader mellan Left och Right

7) Om Left.ok() == true och Right.ok() == true, returnerar en weekday i intervallet [days{0}, days{6}].

8) Returnerar antalet dagar mellan två vardagar.

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

10) Returnerar years(int(y) - int(y2)). Om du subtraherar två year värden resulterar det i en std::chrono::years, som representerar skillnaden i år mellan y och y2. Till 2021y-2000y exempel genererar years(21).

11) Returnerar resultatet av att subtrahera månader eller år från ett year_month värde.

12) Returnerar resultatet av subtrahering av månader år från ett year_month_day värde.

13) Returnerar resultatet av att subtrahera antalet månader från year_month_day_last värdet. I huvudsak: ymdl-dm.

14) Returnerar resultatet av att subtrahera antalet år från year_month_day_last värdet. I huvudsak: ymdl-dy.

15) Returnerar resultatet av att subtrahera antalet månader från year_month_weekday värdet. I huvudsak: ymwd-dm.

16) Returnerar resultatet av att subtrahera antalet år från year_month_weekday värdet. I huvudsak: ymwd-dy.

17) Returnerar resultatet av att subtrahera antalet månader från year_month_weekday_last värdet. I huvudsak: ymwdl-dm.

18) Returnerar resultatet av att subtrahera antalet år från year_month_weekday_last värdet. I huvudsak: ymwdl-dy.

Exempel: `operator-`

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

using namespace std::chrono;

int main()
{
    // day
    day d{10};
    d = d - days(5);
    std::cout << d << '\n'; // 05

    // month
    month m{2};
    m = m - months{1};
    std::cout << m << '\n'; // Jan
    m = m - months{1};
    std::cout << m << '\n'; // Dec

    // year
    auto diff1 = 2021y-2000y;
    auto diff2 = 2021y-years{1};
    std::cout << diff1.count() << '\n'; // 21
    std::cout << diff2 << '\n'; // 2020

    // year_month
    const year theYear{ 2021 };
    year_month ym1{theYear, June};
    year_month ym2 = ym1 - months{2};
    std::cout << ym2 << '\n'; // 2021/Apr
    year_month ym3 = ym1 - years{2};
    std::cout << ym3 << '\n'; // 2019/Jun

    // year_month_day_last
    year_month_day_last ymdl = June / last / 2021;
    std::cout << ymdl - years{1} - months{1} << '\n'; // 2020/May/last

    // year_month_weekday
    year_month_weekday ymw{ year(1997) / January / Wednesday[1] };
    std::cout << ymw - months{1} << '\n'; // 1996/Dec/Wed[1]
    std::cout << ymw - years{1} << '\n'; // 1996/Jan/Wed[1]

    // year_month_weekday_last
    year_month_weekday_last ymwl{ year(1997) / January / Wednesday[last] };
    std::cout << ymwl - months{ 1 } << '\n'; // 1996/Dec/Wed[last]
    std::cout << ymwl - years{ 1 } << '\n'; // 1996/Jan/Wed[last]

    return 0;
}

05
Jan
Dec
21
2020
2021/Apr
2019/Jun
2020/May/last
1996/Dec/Wed[1]
1996/Jan/Wed[1]
1996/Dec/Wed[last]
1996/Jan/Wed[last]

Unär `operator-`

Negates a duration.

constexpr common_type_t<duration> operator-() const;

Returvärde

Returnerar en negerad kopia av *this

Exempel: unary `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!=`

Avgör om:

1) Två duration objekt representerar inte samma antal fästingar.
2) Två time_point objekt representerar inte samma tidpunkt.

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

Parameterar

Left
Vänster duration eller time_point objekt.

Right
Höger duration eller time_point objekt.

Returvärde

1) Returnerar true om antalet tick för den typ som är gemensam för Left och Right inte är lika med. Annars returnerar false.
2) Returnerar true om de två time_point objekten inte representerar samma tidpunkt. Annars returnerar false.

`operator*`

Multiplikationsoperator för duration objekt. När du har konverterat durationde värden som multipliceras till deras gemensamma typ returnerar en duration med ett tickantal som är lika med multiplikationen för de konverterade tickantalen.

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

Parameterar

Dur
Ett duration objekt.

Mult
Ett integralvärde.

Returvärde

Returnerar ett duration objekt vars intervalllängd Mult multipliceras med längden på Dur.

1) Om den inte is_convertible<Rep2, common_type<Rep1, Rep2>>innehåller true, deltar inte den här funktionen i överbelastningsupplösning. Mer information finns i< type_traits>.

2) Om den inte is_convertible<Rep1, common_type<Rep1, Rep2>>innehåller true, deltar inte den här funktionen i överlagringsupplösning. Mer information finns i< type_traits>.

`operator<`

1) När du har konverterat durationde s som jämförs med deras gemensamma typ, avgör om antalet fästingar för Left är färre än för Right.

2) Avgör om tidpunkten sedan epoken Lefttime_point för är mindre än tiden sedan epoken time_point i i 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);

Parameterar

Left
Vänster duration eller time_point objekt.

Right
Höger duration eller time_point objekt.

Returvärde

1) Returnerar true om antalet tick för Left är mindre än antalet tick för Right. Annars returnerar falsefunktionen .

2) Returnerar true om Left föregår Right. Annars returnerar false.

`operator<=`

1) När du har konverterat durations som jämförs med deras gemensamma typ, avgör om antalet fästingar för Left är färre eller samma som Right.

2) Avgör om tidpunkten sedan epoken Lefttime_point för är mindre än eller lika med tiden sedan epoken i time_point i 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);

Parameterar

Left
Vänster duration eller time_point objekt.

Right
Höger duration eller time_point objekt.

Returvärde

1) Returnerar true om antalet tick för Left är mindre än eller lika med antalet tick för Right. Annars returnerar falsefunktionen .

2) Returnerar true om Left föregår, eller är lika med, Right. Annars returnerar false.

`operator==`

Avgör om:

1) duration objekt representerar tidsintervall som har samma längd.
2) time_point objekt representerar samma tidpunkt.
3) day objekt representerar samma dag.
4) month objekt representerar samma månad.
5) month_day objekt representerar samma månad och dag.
6) month_day_last objekt representerar samma månad.
7) month_weekday objekt representerar samma månad och nth veckodag.
8) month_weekday_last objekt representerar samma månad och senaste veckodag.
9) weekday objekt representerar samma veckodag.
10) weekday_last objekt representerar samma sista veckodag i månaden.
11) weekday_indexed representerar samma veckodagsindex.
12) year representerar samma år.
13) year_month representerar samma år och månad.
14) year_month_day representerar samma år, månad och dag.
15) year_month_day_last representerar samma sista dag på året och månaden.
16) year_month_weekday representerar samma veckodag, år och månad.
17) year_month_weekday_last representerar samma sista veckodag i månaden, året och månaden.
18) time_zone_link har samma name. Namnet target beaktas inte.
19) zoned_time representerar samma tidszon.

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

Parameterar

Left
Det vänstra objektet som ska jämföras, till exempel Left == Right

Right
Rätt objekt att jämföra.

Returvärde

1) Returnerar true om antalet tick för den typ som är gemensam för Left och Right är lika med. Annars returnerar false.
2) Returnerar true om Left och Right representerar samma tidpunkt. Annars returnerar false.
3–17) Returnerar true om Left och Right har samma värde. Annars returnerar false.
18) Returnerar true om Left.name() == Right.name(). Annars returnerar false.
19) Returnerar true om Left.get_time_zone() == Right.get_time_zone() && Left.get_sys_time() == Right.get_sys_time();

`operator>`

1) När du har konverterat durations som jämförs med deras gemensamma typ, avgör om antalet fästingar för Left är större än för Right.

2) Avgör om tidpunkten sedan epoken Lefttime_point för är större än tiden sedan epoken time_point i i 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);

Parameterar

Left
Vänster duration eller time_point objekt.

Right
Höger duration eller time_point objekt.

Returvärde

1) Returnerar true om antalet tick för Left är större än antalet tick för Right. Annars returnerar falsefunktionen .

2) Returnerar true om Left kommer efter Right. Annars returnerar false.

`operator>=`

1) När du har konverterat durations som jämförs med deras gemensamma typ, avgör om antalet fästingar för Left är större än eller lika Rightmed .

2) Avgör om tidpunkten eftersom epoken Lefttime_point för är större än eller lika med tiden sedan epoken time_point i i 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);

Parameterar

Left
Vänster duration eller time_point objekt.

Right
Höger duration eller time_point objekt.

Returvärde

1) Returnerar true om antalet tick för Left är större än eller lika med antalet tick för Right. Annars returnerar falsefunktionen .

2) Returnerar true om Left kommer efter, eller är lika med, Right. Annars returnerar false.

`operator<=>`

Rymdskeppsoperatorn, med operator==, syntetiserar operatorer för <, <=, >, >=och != för följande typer:

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;

Parameterar

Left, Right
Den day, duration, month, month_day, month_day_last, time_point, time_zone_link, year, , year_month, , year_month_dayyear_month_day_last för att jämföra.

Returvärde

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

2)
Motsvarar: Left.month() <=> Right.month()

3)
Motsvarar:

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

4)
Motsvarar:

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

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

Mata ut följande typer till en ström:

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

Parameterar

CharT
Datatypen för ett enskilt tecken som ska läsas från strömmen och lagras i strängen. C++-standardbiblioteket innehåller specialiseringar av den här klassmallen, med de typdefinitioner som string för element av typen char, wstring, för wchar_t, u16string för char16_toch u32string för char32_t.

Traits
Beskriver CharT attribut för basic_string och basic_istream specialisering.

os
Utdataströmmen som värdet ska genereras day till.

d
Till-utdata day .

hms
Till-utdata hh_mm_ss .

li
Till-utdata local_info .

m
Till-utdata month .

md
Till-utdata month_day .

mdl
Till-utdata month_day_last .

mwd
Till-utdata month_weekday .

mwdl
Till-utdata month_weekday_last .

si
Till-utdata sys_info .

t
Utdata local_time, gps_time, tai_timeeller utc_time till.

TimeZonePtr
En pekare till time_zone som lagras i zoned_time.

wd
Till-utdata weekday .

wdi
Till-utdata weekday_indexed .

wdl
Till-utdata weekday_last .

y
Till-utdata year .

ym
Till-utdata year_month .

ymd
Till-utdata year_month_day .

ymdl
Till-utdata year_month_day_last .

ymwd
Till-utdata year_month_weekday .

ymwdl
Till-utdata year_month_weekday_last .

zt
Till-utdata zoned_time .

Returvärde

Utdataströmmen som du skickade in, os

Anmärkningar

1) Värdet day är utdata som ett decimaltal, med en inledande nolla om resultatet skulle bli en enda siffra. Om !d.ok()läggs "är inte en giltig dag" till i utdata.

2) Värdet hh_mm_ss är utdata som hours:minutes:seconds:thousandths of seconds. Till exempel "00:00:05.721"

3) Det förkortade månadsnamnet, med hjälp av språkvarianten som är associerad med os, är utdata. Till exempel Jan. Om !m.ok()läggs till " is not a valid month" i utdata.

4) Det förkortade månadsnamnet, med hjälp av språkvarianten som är associerad med os, följt av datumet, med en inledande nolla om resultatet skulle bli en ensiffrig, är utdata. Till exempel Jan/05. Om !md.ok(), kan läggas " is not a valid month" till i utdata för månaden och "is not a valid day" kan läggas till i dagens utdata. Till exempel 204 is not a valid month/204 is not a valid day.

5) Det förkortade månadsnamnet med hjälp av språkvarianten som är associerad med os, följt av /last. Till exempel Jan/last.

6) Det förkortade veckodagsnamnet med hjälp av språkvarianten som är associerad med os, följt av den n:e veckodagen i månaden som den representerar inom hakparenteser. Till exempel Mon[1].

7) Det förkortade veckodagsnamnet med hjälp av språkvarianten som är associerad med os, följt av den sista veckodagen i månaden som den representerar inom hakparenteser. Till exempel Jan/Mon[last].

8) Det förkortade veckodagsnamnet, med hjälp av det språk som är associerat med os, är utdata. Om !wd.ok()läggs till " is not a valid weekday" i utdata.

9) Det förkortade veckodagsnamnet, med hjälp av det språk som är associerat med os, är utdata följt av veckodagen i månaden inom hakparenteser. Till exempel Mon[3]. Om !wd.ok(), kan sedan " is not a valid weekday" läggas till i veckodagens utdata och "is not a valid index" kan läggas till i veckodagsindexutdata.

10) Den sista veckodagen i en månad, med hjälp av språkvarianten som är associerad med os, är utdata följt av [last], följt av datumet. Till exempel Tue[last] 2019-10-29. Om !wd.ok(), kan sedan " is not a valid weekday" läggas till i veckodagens utdata och "is not a valid index" kan läggas till i veckodagsindexutdata.

11) Året är vänster vadderat med 0 (noll) till fyra siffror om resultatet skulle vara mindre än så. Om !y.ok()läggs till " is not a valid year" i utdata.

12) year_month är utdata i formuläret yyyy-mm-dd. Om ym.ok returnerar falseläggs den " is not a valid date" till.

13) year_month_day är utdata i formuläret yyyyy-mm-dd. Om ymd.ok returnerar falseläggs den " is not a valid date" till.

14) year_month_day_last är utdata i formuläret yyyyy/month/last. Till exempel 2020/May/last.

15) year_month_weekday är utdata i form yyyy/month/weekday[index]. Till exempel: 1996/Jan/Wed[1]

16) year_month_weekday_last Är utdata i bilda yyyy/month/weekday[sist]. Till exempel: 1996/Jan/Wed[last]

17) tai_time är utdata i formuläret åååå-mm-dd hh:mm:ss.ssssss. Till exempel: 2021-08-13 23:23:08.4358666

18) utc_time är utdata i formuläret åååå-mm-dd hh:mm:ss.ssss. Till exempel: 2021-08-13 23:23:08.4358666

19) gps_time är utdata i formuläret åååå-mm-dd hh:mm:ss.ssssss. Till exempel: 2021-08-13 23:23:08.4358666

20) local_time Är utdata som antalet sekunder sedan klockans epok. Det är utdata som om av os << std::chrono::sys_time<Duration>(some_local_time.time_since_epoch());. Om till exempel some_local_time är 18 augusti 2021 15:13 är 1597792380utdata .

21) I Microsofts implementering är en sys_info utdata som fälten begin, end, offset, saveoch abbrev . Till exempel: begin: 2021-03-14 10:00:00, end: 2021-11-07 09:00:00, offset: -25200s, save: 60min, abbrev: PDT

22) I Microsofts implementering är en local_info utdata som åååå-mm-dd hh:mm:ss.ssss. Till exempel: 2021-09-17 13:55:59.6590120

23) Den lokala tiden i zoned_time (erhålls som zt.get_local_time()) är utdata med formatet åååå-mm-dd hh:mm:ss tidszon. Till exempel: 2021-09-15 10:45:00 GMT-6

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

Operator för modulo-åtgärder på 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);

Parameterar

Dur
Ett duration objekt.

Div
Ett integralvärde.

Left
Utdelningen. Modulo är resten efter uppdelning av utdelningen med divisor.

Right
Det högra duration objektet, divisorn.

Returvärde

1) Returnerar ett duration objekt vars intervalllängd är Dur modulo Div.

2) Returnerar ett värde som representerar Left modulo Right.

`operator/` för `duration`

Divisionsoperator för duration objekt.

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

Parameterar

Dur
Ett duration objekt.

Div
Ett integralvärde.

Left
Det vänstra duration objektet.

Right
Det högra duration objektet.

Returvärde

1) Ett varaktighetsobjekt vars intervalllängd är längden på Dur dividerat med värdet Div.

2) Förhållandet mellan intervalllängderna Left för och Right.

Om inte is_convertible<Rep2, common_type<Rep1, Rep2>>är sant, och Rep2 inte är en instansiering av duration, deltar inte den första operatorn i överbelastningsmatchning. Mer information finns i< type_traits>.

`operator/` för kalenderdatum

Innehåller syntax för att skapa kalenderdatum i följande formulär:

månad/dag/år
dag/månad/år
år/månad/dag

Du kan ersätta dagen med:

last
weekday[n] för den n:e dagen i månaden
weekday[last] för den sista weekday månaden.

Partiella datum kan skapas på följande sätt:

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

Heltal kan användas så länge tolkningen inte är tvetydig.

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

Parameterar

d
Dagen. Tillhandahålls antingen som ett heltal i intervallet [1,31] eller som ett day.

lastspec
En tom taggtyp som anger det sista objektet i en sekvens. Till exempel 2021y/May/last är den sista dagen i maj 2021.

m
Månaden. Tillhandahålls antingen som ett heltal i intervallet [1,12] eller som ett month.

md
Månad och dag.

mdl
Den sista dagen i den angivna månaden.

mwd
Den n:e veckodagen för den angivna månaden.

mwdl
Den sista veckodagen för den angivna månaden.

wdi
Ett veckodagsindex (weekday_indexed). Till exempel weekday_indexed(Monday, 1) är den första måndagen i en månad.

wdl
Den sista veckodagen i en månad. Till exempel Monday[last] är den sista måndagen i en månad.

y
Året. Tillhandahålls antingen som ett heltal eller som en year.

ym
Året och månaden.

Returvärde

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

Exempel: `operator/` för kalenderdatum

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

using namespace std::chrono;

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

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

    return 0;
}

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

Feedback

Var den här sidan till hjälp?

Dela via

<chrono> operatörer

operator+

Returvärde

Exempel: operator+

Unär operator+

Returvärde

operator-

Returvärde

Exempel: operator-

Unär operator-

Returvärde

Exempel: unary operator-

operator!=

Parameterar

Returvärde

operator*

Parameterar

Returvärde

operator<

Parameterar

Returvärde

operator<=

Parameterar

Returvärde

operator==

Parameterar

Returvärde

operator>

Parameterar

Returvärde

operator>=

Parameterar

Returvärde

operator<=>

Parameterar

Returvärde

Exempel: operator<=>

operator<<

Parameterar

Returvärde

Anmärkningar

Exempel: operator<<

operator modulo

Parameterar

Returvärde

operator/ för duration

Parameterar

Returvärde

operator/ för kalenderdatum

Parameterar

Returvärde

Exempel: operator/ för kalenderdatum

Feedback

Ytterligare resurser

`<chrono>` operatörer

`operator+`

Exempel: `operator+`

Unär `operator+`

`operator-`

Exempel: `operator-`

Unär `operator-`

Exempel: unary `operator-`

`operator!=`

`operator*`

`operator<`

`operator<=`

`operator==`

`operator>`

`operator>=`

`operator<=>`

Exempel: `operator<=>`

`operator<<`

Exempel: `operator<<`

`operator modulo`

`operator/` för `duration`

`operator/` för kalenderdatum

Exempel: `operator/` för kalenderdatum