`<chrono>` – operátory

Článek
03/29/2024

`operator+`

Operátor sčítání pro následující typy:

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

Vrácená hodnota

1) Po převodu Left a Right na jejich společný typ vrátí duration hodnotu s počtem záškrtů, který se rovná součtu převedených počtů.

2-3) Vrátí time_point objekt, který představuje bod v čase, který je nahrazen intervalem Dur od bodu v čase Time.

4) Vrátí výsledek .d+ds.count() Pokud je výsledek mimo rozsah [0, 255], je výsledek nezadaný.

5) Vrátí výsledek funkce m+ms.count(). Pokud je výsledek mimo rozsah [1, 12], sníží se modulo 12 a pak +1.

6) Vrátí výsledek sčítání počtu dní a pracovních dnů do weekday. Výsledkem bude modulo 7, takže vždy v rozsahu [0,6]

7) Vrátí výsledek sčítání roku k zadanému počtu roků.

8) Vrátí výsledek sčítání počtu měsíců a roků do zadaného měsíce a roku.

9) Vrátí výsledek sčítání měsíců nebo roků do .year_month_day Pokud ymd.month() je February a ymd.day() není v rozsahu [1d, 28d], ok() může se vrátit false pro výsledek sčítání.

10) Vrátí (ymdl.year() / ymdl.month() + dm) / last. Poznámka: Použitý operátor / není operátor dělení. Jedná se o operátor data.

11) Vrátí ymdl + dm.

12) Vrátí {ymdl.year()+dy, ymdl.month_day_last()}

13) Vrátí ymwd + dm.count().

14-15) Vrátí {ymwd.year()+dy, ymwd.month(), ymwd.weekday_indexed()}.

16) Vrátí (ymwdl.year() / ymwdl.month() + dm) / ymwdl.weekday_last(). Poznámka: Použitý / operátor není operátor dělení, ale operátor data.

17) Vrátí: ymwdl + dy

Příklad: `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ární `operator+`

Použití unárního plus u následujících typů:

duration.

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

Vrácená hodnota

Návraty *this

`operator-`

Operátor odčítání pro následující typy:

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

Vrácená hodnota

1) Po převodu doby trvání odečítané na jejich společný typ vrátí duration hodnotu s počtem záškrtů Right , který se rovná počtu odškrtnutí od počtu odškrtnutí Left.

2) Vrátí time_point hodnotu, která představuje bod v čase, který je nahrazen negací časového intervalu, který je reprezentován Dur, od bodu v čase, který je určen Time.

3) Vrátí duration objekt, který představuje časový interval mezi Left a Right.

4) Vrátí výsledek .d-ds.count() Pokud je výsledek mimo rozsah [0, 255], je výsledek nezadaný.

5) Pokud m.ok() == true a ms.ok() == true, vrátí výsledek odečtení dvou měsíčních hodnot nebo odečtení počtu měsíců. Výsledek bude v rozsahu [1, 12]. Pokud je výsledek záporný, obtéká kolem. Například odečtení jednoho měsíce od ledna (month m1{1} - months{1}; výsledkem je 12 (prosinec).

6) Vrátí rozdíl v měsících mezi Left a Right

7) Pokud Left.ok() == true a Right.ok() == true, vrátí v weekday oblasti [days{0}, days{6}].

8) Vrátí počet dní mezi dvěma pracovními dny.

9) Vrátí year(int(y)-ys.count)())

10) Vrátí years(int(y) - int(y2)). Odečtením dvou year hodnot vznikne std::chrono::yearsvýsledek , který představuje rozdíl v letech mezi y a y2. Například 2021y-2000y vytvoří years(21).

11) Vrátí výsledek odečtení měsíců nebo roků od year_month hodnoty.

12) Vrátí výsledek odečtení roků od year_month_day hodnoty.

13) Vrátí výsledek odečtení počtu měsíců od year_month_day_last hodnoty. V podstatě: ymdl-dm.

14) Vrátí výsledek odečtení počtu roků od year_month_day_last hodnoty. V podstatě: ymdl-dy.

15) Vrátí výsledek odečtení počtu měsíců od year_month_weekday hodnoty. V podstatě: ymwd-dm.

16) Vrátí výsledek odečtení počtu roků od year_month_weekday hodnoty. V podstatě: ymwd-dy.

17) Vrátí výsledek odečtení počtu měsíců od year_month_weekday_last hodnoty. V podstatě: ymwdl-dm.

18) Vrátí výsledek odečtení počtu roků od year_month_weekday_last hodnoty. V podstatě: ymwdl-dy.

Příklad: `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]

Unární `operator-`

Negates a duration.

constexpr common_type_t<duration> operator-() const;

Vrácená hodnota

Vrátí negovanou kopii *this

Příklad: unární `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!=`

Určuje, jestli:

1) Dva duration objekty nepředstavují stejný počet záškrtů.
2) Dva time_point objekty nepředstavují stejný bod v čase.

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

Parametry

Left
Levý duration nebo time_point objekt.

Right
duration Pravý objekt nebo time_point objekt.

Vrácená hodnota

1) Vrátí true , pokud počet záškrtů pro typ společný Left a Right není roven. V opačném případě vrátí hodnotu false.
2) Vrátí true , pokud dva time_point objekty nepředstavují stejný bod v čase. V opačném případě vrátí hodnotu false.

`operator*`

Operátor násobení pro duration objekty Po převodu durationnásobených hodnot na společný typ vrátí duration hodnotu s počtem záškrtů, který se rovná násobení převedených počtů.

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

Parametry

Dur
Objekt duration .

Mult
Celočíselnou hodnotu.

Vrácená hodnota

Vrátí objekt, duration jehož délka intervalu je Mult vynásobená délkou Dur.

1) Není-li is_convertible<Rep2, common_type<Rep1, Rep2>>truetoto blokování , tato funkce se neúčastní řešení přetížení. Další informace najdete v tématu <type_traits>.

2) Pokud is_convertible<Rep1, common_type<Rep1, Rep2>>tuto funkci nezadržíte true, nebude se tato funkce účastnit řešení přetížení. Další informace najdete v tématu <type_traits>.

`operator<`

1) Po převodu srovnané s durationjejich běžným typem určuje, zda je počet záškrtů Left menší než pro Right.

2) Určuje, zda bod v čase od epochy Lefttime_point je kratší než čas od epochy time_point in Right.

1)
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator<(
    const duration<Rep1, Period1>& Left,
    const duration<Rep2, Period2>& Right);

2)
template <class Clock, class Duration1, class Duration2>
constexpr bool operator<(
    const time_point<Clock, Duration1>& Left,
    const time_point<Clock, Duration2>& Right);

Parametry

Left
Levý duration nebo time_point objekt.

Right
duration Pravý objekt nebo time_point objekt.

Vrácená hodnota

1) Vrátí true , pokud je počet klíštěk Left menší než počet záškrtů pro Right. V opačném případě funkce vrátí falsehodnotu .

2) Vrátí true , pokud Left předchází Right. V opačném případě vrátí hodnotu false.

`operator<=`

1) Po převedení srovnané s durationjejich společným typem určuje, zda je počet záškrtů Left menší nebo stejný jako Right.

2) Určuje, zda bod v čase od epochy Lefttime_point je menší nebo roven času od epochy time_point in Right.

1)
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator<=(
    const duration<Rep1, Period1>& Left,
    const duration<Rep2, Period2>& Right);

2)
template <class Clock, class Duration1, class Duration2>
constexpr bool operator<=(
    const time_point<Clock, Duration1>& Left,
    const time_point<Clock, Duration2>& Right);

Parametry

Left
Levý duration nebo time_point objekt.

Right
duration Pravý objekt nebo time_point objekt.

Vrácená hodnota

1) Vrátí true , pokud je počet klíštěk Left menší nebo roven počtu záškrtů pro Right. V opačném případě funkce vrátí falsehodnotu .

2) Vrátí true , pokud Left předchází nebo je rovna, Right. V opačném případě vrátí hodnotu false.

`operator==`

Určuje, jestli:

1) duration objekty představují časové intervaly, které mají stejnou délku.
2) time_point objekty představují stejný bod v čase.
3) day objekty představují stejný den.
4) month objekty představují stejný měsíc.
5) month_day objekty představují stejný měsíc a den.
6) month_day_last objekty představují stejný měsíc.
7) month_weekday objekty představují stejný měsíc a nth weekday.
8) month_weekday_last objekty představují stejný měsíc a poslední den v týdnu.
9) weekday objekty představují stejný pracovní den.
10) weekday_last objekty představují stejný minulý pracovní den v měsíci.
11) weekday_indexed představuje stejný index dne v týdnu.
12) year představují stejný rok.
13) year_month představuje stejný rok a měsíc.
14) year_month_day představuje stejný rok, měsíc a den.
15) year_month_day_last představuje stejný poslední den v roce a měsíci.
16) year_month_weekday představuje stejný pracovní den, rok a měsíc.
17) year_month_weekday_last představuje stejný minulý den v týdnu v měsíci, roce a měsíci.
18) time_zone_link mají stejné name. Název target se nepovažuje.
19) zoned_time představuje stejné časové pásmo a časové pásmo.

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

Parametry

Left
Levý objekt, který se má porovnat, například Left == Right

Right
Správný objekt, který chcete porovnat.

Vrácená hodnota

1) Vrátí true , pokud je počet záškrtů pro typ společný Left a Right je roven. V opačném případě vrátí hodnotu false.
2) Vrátí hodnotu true , pokud Left představuje Right stejný bod v čase. V opačném případě vrátí hodnotu false.
3-17) Vrátí true hodnotu, pokud Left má Right stejnou hodnotu. V opačném případě vrátí hodnotu false.
18) Vrátí true hodnotu if Left.name() == Right.name(). V opačném případě vrátí hodnotu *false*.
19) Vrátí true hodnotu if Left.get_time_zone() == _Right.get_time_zone() && Left.get_sys_time() == Right.get_sys_time();

`operator>`

1) Po převedení srovnávané hodnoty durations běžným typem určuje, zda je počet klíštěk Left větší než pro Right.

2) Určuje, zda bod v čase od epochy Lefttime_point je větší než čas od epochy time_point in Right.

1) 
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator>(
    const duration<Rep1, Period1>& Left,
    const duration<Rep2, Period2>& Right);

2)
template <class Clock, class Duration1, class Duration2>
constexpr bool operator>(
    const time_point<Clock, Duration1>& Left,
    const time_point<Clock, Duration2>& Right);

Parametry

Left
Levý duration nebo time_point objekt.

Right
duration Pravý objekt nebo time_point objekt.

Vrácená hodnota

1) Vrátí true , pokud je počet klíštěk Left větší než počet klíštěk pro Right. V opačném případě funkce vrátí falsehodnotu .

2) Vrátí true , pokud Left přijde po Right. V opačném případě vrátí hodnotu false.

`operator>=`

1) Po převodu srovnané s durationjejich společným typem určuje, zda je počet záškrtů Left větší nebo roven Right.

2) Určuje, zda bod v čase od epochy Lefttime_point je větší nebo roven času od epochy time_point in Right.

1)
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator>=(
    const duration<Rep1, Period1>& Left,
    const duration<Rep2, Period2>& Right);

2)
template <class Clock, class Duration1, class Duration2>
constexpr bool operator>=(
    const time_point<Clock, Duration1>& Left,
    const time_point<Clock, Duration2>& Right);

Parametry

Left
Levý duration nebo time_point objekt.

Right
duration Pravý objekt nebo time_point objekt.

Vrácená hodnota

1) Vrátí true , pokud je počet klíštěk Left větší nebo roven počtu záškrtů pro Right. V opačném případě funkce vrátí falsehodnotu .

2) Vrátí true , pokud Left přichází po, nebo je rovna, Right. V opačném případě vrátí hodnotu false.

`operator<=>`

Operátor vesmírné lodi, s operator==, syntetizuje operátory pro <, <=>, , >=a != pro následující typy:

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;

Parametry

Left, Right
The day, duration, , month, month_day, time_pointyeartime_zone_linkyear_monthmonth_day_lastyear_month_dayporovnat. year_month_day_last

Vrácená hodnota

1)
0 když Left == Right
< 0 když Left < Right
> 0 když Left > Right

2)
Ekvivalentní: Left.month() <=> Right.month()

3)
Ekvivalentní:

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

4)
Ekvivalentní:

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

Příklad: `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<<`

Výstupem následujících typů streamu:

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

Parametry

CharT
Datový typ jednoho znaku, který se má číst z datového proudu a který je uložený v řetězci. Standardní knihovna jazyka C++ poskytuje specializace této šablony třídy s definicemi string typů pro prvky typu char, wstringpro , u16string pro wchar_tchar16_ta u32string pro char32_t.

Traits
Popisuje CharT atributy pro basic_string specializaci a basic_istream specializace.

os
Výstupní datový proud, do který se má hodnota generovat day .

d
Výstup day :

hms
Výstup hh_mm_ss :

li
Výstup local_info :

m
Výstup month :

md
Výstup month_day :

mdl
Výstup month_day_last :

mwd
Výstup month_weekday :

mwdl
Výstup month_weekday_last :

si
Výstup sys_info :

t
The local_time, gps_time, tai_timenebo utc_time to output.

TimeZonePtr
Ukazatel na time_zone uložený v souboru zoned_time.

wd
Výstup weekday :

wdi
Výstup weekday_indexed :

wdl
Výstup weekday_last :

y
Výstup year :

ym
Výstup year_month :

ymd
Výstup year_month_day :

ymdl
Výstup year_month_day_last :

ymwd
Výstup year_month_weekday :

ymwdl
Výstup year_month_weekday_last :

zt
Výstup zoned_time :

Vrácená hodnota

Výstupní datový proud, který jste předali, os

Poznámky

1) Hodnota day je výstupem jako desetinné číslo s úvodní nulou, pokud by výsledkem byla jedna číslice. Pokud !d.ok()se k výstupu připojí text "není platný den".

2) Hodnota hh_mm_ss se zobrazí jako hodina:minutes:seconds:thousandths sekund. Například " "00:00:05.721

3) Zkrácený název měsíce s použitím národního prostředí přidruženého osk , je výstup. Například Jan. Pokud !m.ok()se pak " is not a valid month" připojí k výstupu.

4) Zkrácený název měsíce s použitím národního prostředí přidruženého osk datu, za kterým následuje počáteční nula, pokud by výsledkem byla jedna číslice, je výstup. Například Jan/05. Pokud !md.ok()se pak " is not a valid month" může připojit k výstupu měsíce a "is not a valid day" může být připojen k výstupu dne. Například 204 is not a valid month/204 is not a valid day.

5) Zkrácený název měsíce s použitím národního prostředí spojeného s os, následovaný /last. Například Jan/last.

6) Zkrácený název dne v týdnu s použitím národního prostředí spojeného s os, následovaný nth weekday v měsíci, který představuje v hranatých závorkách. Například Mon[1].

7) Zkrácený název dne v týdnu, pomocí národního prostředí přidruženého osk , následovaný posledním dnem v týdnu v měsíci, který představuje v hranatých závorkách. Například Jan/Mon[last].

8) Zkrácený název dne v týdnu, pomocí národního prostředí přidruženého osk , je výstup. Pokud !wd.ok()se pak " is not a valid weekday" připojí k výstupu.

9) Zkrácený název dne v týdnu, pomocí národního prostředí přidruženého osk , je výstup, následovaný dnem v týdnu měsíce v hranatých závorkách. Například Mon[3]. Pokud !wd.ok()se pak " is not a valid weekday" může připojit ke dni v týdnu výstupu a "is not a valid index" může být připojen k výstupu indexu dne v týdnu.

10) Poslední den v týdnu v měsíci, pomocí národního prostředí přidruženého osk , je výstup, následovaný [last]datem. Například Tue[last] 2019-10-29. Pokud !wd.ok()se pak " is not a valid weekday" může připojit ke dni v týdnu výstupu a "is not a valid index" může být připojen k výstupu indexu dne v týdnu.

11) Rok je vlevo vycpaný číslem 0 (nula) až čtyřmi číslicemi, pokud by výsledek byl menší. Pokud !y.ok()se pak " is not a valid year" připojí k výstupu.

12) Výstup year_month je ve tvaru yyyy-mm-dd. Pokud ym.ok se vrátí false, pak " is not a valid date" se připojí.

13) Výstup year_month_day je ve tvaru yyyyy-mm-dd. Pokud ymd.ok se vrátí false, pak " is not a valid date" se připojí.

14) Výstup year_month_day_last je ve tvaru yyyy/month/last. Například 2020/May/last.

15) Výstup year_month_weekday je ve formátu yyyy/month/weekday[index]. Například 1996/Jan/Wed[1]

16) Výstup year_month_weekday_last je ve formátu yyy/month/weekday[last]. Například 1996/Jan/Wed[last]

17) Výstup tai_time je ve tvaru yyyyy-mm-dd hh:mm:ss.sssssss. Například 2021-08-13 23:23:08.4358666

18) Výstup utc_time je ve tvaru yyyyy-mm-dd hh:mm:ss.sssss. Například 2021-08-13 23:23:08.4358666

19) Výstup gps_time je ve tvaru yyyyy-mm-dd hh:mm:ss.ssssssss. Například 2021-08-13 23:23:08.4358666

20) Výstup local_time je jako počet sekund od epochy hodin. Je to výstup, jako by os << std::chrono::sys_time<Duration>(some_local_time.time_since_epoch());. Pokud je například some_local_time 18. srpna 2021 13:13, výstup je 1597792380.

21) V implementaci Microsoftu sys_info je výstupem jeho begin, end, offsetsavea abbrev pole. Příklad: begin: 2021-03-14 10:00:00, end: 2021-11-07 09:00:00, offset: -25200s, save: 60min, abbrev: PDT

22) V implementaci Microsoftu local_info je výstup jako yyyy-mm-dd hh:mm::ss.sssssss. Například 2021-09-17 13:55:59.6590120

23) Místní čas ve výstupu zoned_time (získaného jako zt.get_local_time()) je ve formátu rrrr-mm-dd hh:mm:ss časové pásmo. Například 2021-09-15 10:45:00 GMT-6

Příklad: `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`

Operátor pro operace modulo na 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);

Parametry

Dur
Objekt duration .

Div
Celočíselnou hodnotu.

Left
Dividenda. Modulo je zbytek po vydělení dělitelem.

Right
Pravý duration objekt, dělitel.

Vrácená hodnota

1) Vrátí duration objekt, jehož délka intervalu je Dur modulo Div.

2) Vrátí hodnotu, která představuje Left modulo Right.

`operator/` pro `duration`

Operátor dělení pro duration objekty

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

Parametry

Dur
Objekt duration .

Div
Celočíselnou hodnotu.

Left\w Levý duration objekt.

Right
Správný duration objekt.

Vrácená hodnota

1) Objekt doby trvání, jehož délka intervalu Dur je délka dělená hodnotou Div.

2) Poměr délky intervalů Left a Right.

Pokud is_convertible<Rep2, common_type<Rep1, Rep2>>nemá hodnotu true a Rep2 nejedná se o durationvytvoření instance , první operátor se neúčastní rozlišení přetížení. Další informace najdete v tématu <type_traits>.

`operator/` pro kalendářní data

Poskytuje syntaxi pro vytváření kalendářních dat v následujících formulářích:

month/day/year
den/měsíc/rok
year/month/day

Den můžete nahradit:

last
weekday[n] pro n. den v měsíci
weekday[last] za poslední weekday měsíc.

Částečná data lze vytvořit takto:

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

Celá čísla se dají použít, pokud interpretace není nejednoznačná.

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

Parametry

d
Den. Poskytuje se buď jako celé číslo v rozsahu [1,31], nebo jako .day

lastspec
Prázdný typ značky, který označuje poslední položku v posloupnosti. Například 2021y/May/last poslední den v květnu 2021.

m
Měsíc. Poskytuje se buď jako celé číslo v rozsahu [1,12], nebo jako .month

md
Měsíc a den.

mdl
Poslední den zadaného měsíce.

mwd
N-th weekday of the specified month.

mwdl
Poslední den v týdnu zadaného měsíce.

wdi
Index dne v týdnu (weekday_indexed). Jedná se například weekday_indexed(Monday, 1) o první pondělí v měsíci.

wdl
Poslední den v týdnu měsíce. Například Monday[last] poslední pondělí v měsíci.

y
Rok. Poskytuje se buď jako celé číslo, nebo jako year.

ym
Rok a měsíc.

Vrácená hodnota

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

Příklad: `operator/` pro kalendářní data

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

Sdílet prostřednictvím

<chrono> – operátory

operator+

Vrácená hodnota

Příklad: operator+

Unární operator+

Vrácená hodnota

operator-

Vrácená hodnota

Příklad: operator-

Unární operator-

Vrácená hodnota

Příklad: unární operator-

operator!=

Parametry

Vrácená hodnota

operator*

Parametry

Vrácená hodnota

operator<

Parametry

Vrácená hodnota

operator<=

Parametry

Vrácená hodnota

operator==

Parametry

Vrácená hodnota

operator>

Parametry

Vrácená hodnota

operator>=

Parametry

Vrácená hodnota

operator<=>

Parametry

Vrácená hodnota

Příklad: operator<=>

operator<<

Parametry

Vrácená hodnota

Poznámky

Příklad: operator<<

operator modulo

Parametry

Vrácená hodnota

operator/ pro duration

Parametry

Vrácená hodnota

operator/ pro kalendářní data

Parametry

Vrácená hodnota

Příklad: operator/ pro kalendářní data

Váš názor

Další materiály

`<chrono>` – operátory

`operator+`

Příklad: `operator+`

Unární `operator+`

`operator-`

Příklad: `operator-`

Unární `operator-`

Příklad: unární `operator-`

`operator!=`

`operator*`

`operator<`

`operator<=`

`operator==`

`operator>`

`operator>=`

`operator<=>`

Příklad: `operator<=>`

`operator<<`

Příklad: `operator<<`

`operator modulo`

`operator/` pro `duration`

`operator/` pro kalendářní data

Příklad: `operator/` pro kalendářní data