Namespaces
Variants

operator+,-,*,/,% (std::chrono::duration)

From cppreference.net
C++
Date and time library
std::chrono::duration
Member functions
Non-member functions
operator+ operator- operator* operator/ operator%
(until C++20) (C++20)
(C++20)
Helper classes
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur wurde gemäß den Anforderungen unverändert beibehalten.)
template < class Rep1, class Period1, class Rep2, class Period2 >

typename std:: common_type < duration < Rep1,Period1 > , duration < Rep2,Period2 >> :: type
constexpr operator + ( const duration < Rep1,Period1 > & lhs,

const duration < Rep2,Period2 > & rhs ) ;
(1) (seit C++11)
template < class Rep1, class Period1, class Rep2, class Period2 >

typename std:: common_type < duration < Rep1,Period1 > , duration < Rep2,Period2 >> :: type
constexpr operator - ( const duration < Rep1,Period1 > & lhs,

const duration < Rep2,Period2 > & rhs ) ;
(2) (seit C++11)
template < class Rep1, class Period, class Rep2 >

duration < typename std:: common_type < Rep1,Rep2 > :: type , Period >
constexpr operator * ( const duration < Rep1,Period > & d,

const Rep2 & s ) ;
(3) (seit C++11)
template < class Rep1, class Rep2, class Period >

duration < typename std:: common_type < Rep1,Rep2 > :: type , Period >
constexpr operator * ( const Rep1 & s,

const duration < Rep2,Period > & d ) ;
(4) (seit C++11)
template < class Rep1, class Period, class Rep2 >

duration < typename std:: common_type < Rep1,Rep2 > :: type , Period >
constexpr operator / ( const duration < Rep1,Period > & d,

const Rep2 & s ) ;
(5) (seit C++11)
template < class Rep1, class Period1, class Rep2, class Period2 >

typename std:: common_type < Rep1,Rep2 > :: type
constexpr operator / ( const duration < Rep1,Period1 > & lhs,

const duration < Rep2,Period2 > & rhs ) ;
(6) (seit C++11)
template < class Rep1, class Period, class Rep2 >

duration < typename std:: common_type < Rep1,Rep2 > :: type , Period >
constexpr operator % ( const duration < Rep1, Period > & d,

const Rep2 & s ) ;
(7) (seit C++11)
template < class Rep1, class Period1, class Rep2, class Period2 >

typename std:: common_type < duration < Rep1,Period1 > , duration < Rep2,Period2 >> :: type
constexpr operator % ( const duration < Rep1,Period1 > & lhs,

const duration < Rep2,Period2 > & rhs ) ;
(8) (seit C++11)

Führt grundlegende arithmetische Operationen zwischen zwei Dauern oder zwischen einer Dauer und einer Tickanzahl durch.

1) Konvertiert die beiden Dauern in ihren gemeinsamen Typ und erstellt eine Dauer, deren Taktanzahl die Summe der Taktanzahlen nach der Konvertierung ist.
2) Wandelt die beiden Dauern in ihren gemeinsamen Typ um und erstellt eine Dauer, deren Tickanzahl die rhs Anzahl von Ticks subtrahiert von der lhs Anzahl von Ticks nach der Konvertierung ist.
3,4) Konvertiert die Dauer d zu einer Dauer, deren rep der gemeinsame Typ zwischen Rep1 und Rep2 ist, und multipliziert die Anzahl der Ticks nach der Konvertierung mit s . Diese Überladungen nehmen nur dann an der Überladungsauflösung teil, wenn s konvertierbar ist zu typename std:: common_type < Rep1, Rep2 > :: type .
5) Konvertiert die Dauer d zu einer Dauer, deren rep der gemeinsame Typ zwischen Rep1 und Rep2 ist, und teilt die Anzahl der Ticks nach der Konvertierung durch s . Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn s konvertierbar ist zu typename std:: common_type < Rep1, Rep2 > :: type und Rep2 keine Spezialisierung von duration ist.
6) Konvertiert die beiden Zeitdauern in ihren gemeinsamen Typ und dividiert die Tickanzahl von lhs nach der Konvertierung durch die Tickanzahl von rhs nach der Konvertierung. Hinweis: Der Rückgabewert dieses Operators ist keine Zeitdauer.
7) Konvertiert die Dauer d zu einer Dauer, deren rep der gemeinsame Typ zwischen Rep1 und Rep2 ist, und erstellt eine Dauer, deren Tick-Zähler der Rest der Division des Tick-Zählers nach der Konvertierung durch s ist. Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn s konvertierbar ist zu typename std:: common_type < Rep1, Rep2 > :: type und Rep2 keine Spezialisierung von duration ist.
8) Konvertiert die beiden Dauern in ihren gemeinsamen Typ und erstellt eine Dauer, deren Taktanzahl der Rest der Taktanzahlen nach der Konvertierung ist.

Inhaltsverzeichnis

Parameter

lhs - Dauer auf der linken Seite des Operators
rhs - Dauer auf der rechten Seite des Operators
d - das Dauerargument für Operatoren mit gemischten Argumenten
s - Nicht-Dauer-Argument für Operatoren mit gemischten Argumenten

Rückgabewert

Angenommen, dass CD der Rückgabetyp der Funktion ist und CD < A, B > = std:: common_type < A, B > :: type , dann:

1) CD ( CD ( lhs ) . count ( ) + CD ( rhs ) . count ( ) )
2) CD ( CD ( lhs ) . count ( ) - CD ( rhs ) . count ( ) )
3,4) CD ( CD ( d ) . count ( ) * s )
5) CD ( CD ( d ) . count ( ) / s )
6) CD ( lhs ) . count ( ) / CD ( rhs ) . count ( ) (der Rückgabetyp dieses Operators ist keine Dauer)
7) CD ( CD ( d ) . count ( ) % s )
8) CD ( CD ( lhs ) . count ( ) % CD ( rhs ) . count ( ) )

Beispiel

Diesen Code ausführen 
#include <chrono>
#include <iostream>
int main()
{
    // Einfache Arithmetik:
    std::chrono::seconds s = std::chrono::hours(1)
                           + 2 * std::chrono::minutes(10)
                           + std::chrono::seconds(70) / 10;
    std::cout << "1 Stunde + 2*10 min + 70/10 sec = " << s << " (Sekunden)\n";
    using namespace std::chrono_literals;
    // Unterschied zwischen Division einer Dauer durch eine Zahl
    // und Division einer Dauer durch eine andere Dauer:
    std::cout << "Division durch 2 Minuten ergibt "
              << s / 2min << '\n'
              << "Division durch 2 ergibt "
              << (s / 2).count() << " Sekunden\n";
    // Der Restoperator ist nützlich, um zu bestimmen, wo
    // in einem Zeitrahmen sich diese bestimmte Dauer befindet, z.B. um
    // sie in Stunden, Minuten und Sekunden aufzuteilen:
    std::cout << s << " (Sekunden) = "
              << std::chrono::duration_cast<std::chrono::hours>(
                 s) << " (Stunde) + "
              << std::chrono::duration_cast<std::chrono::minutes>(
                 s % 1h) << " (Minuten) + "
              << std::chrono::duration_cast<std::chrono::seconds>(
                 s % 1min) << " (Sekunden)\n";
    constexpr auto sun_earth_distance{150'000'000ULL}; // km
    constexpr auto speed_of_light{300000ULL}; // km/sec
    std::chrono::seconds t(sun_earth_distance / speed_of_light); // sec
    std::cout << "Ein Photon fliegt von der Sonne zur Erde in "
              << t / 1min << " Minuten " << t % 1min << " (Sekunden)\n";
}

Ausgabe: 

1 Stunde + 2*10 min + 70/10 sec = 4807s (Sekunden)
Division durch 2 Minuten ergibt 40
Division durch 2 ergibt 2403 Sekunden
4807s (Sekunden) = 1h (Stunde) + 20min (Minuten) + 7s (Sekunden)
Ein Photon fliegt von der Sonne zur Erde in 8 Minuten 20s (Sekunden)

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 3050 C++11 convertibility constraint used non-const xvalue use const lvalues instead