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
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) (depuis 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) (depuis 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) (depuis 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) (depuis 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) (depuis 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) (depuis 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) (depuis 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) (depuis C++11)

Effectue des opérations arithmétiques de base entre deux durées ou entre une durée et un nombre de ticks.

1) Convertit les deux durées en leur type commun et crée une durée dont le nombre de ticks est la somme des nombres de ticks après conversion.
2) Convertit les deux durées en leur type commun et crée une durée dont le nombre de ticks est le rhs nombre de ticks soustrait du lhs nombre de ticks après conversion.
3,4) Convertit la durée d en une durée dont le rep est le type commun entre Rep1 et Rep2 , et multiplie le nombre de ticks après conversion par s . Ces surcharges participent à la résolution de surcharge seulement si s est convertible en typename std:: common_type < Rep1, Rep2 > :: type .
5) Convertit la durée d en une durée dont le rep est le type commun entre Rep1 et Rep2 , et divise le nombre de ticks après conversion par s . Cette surcharge participe à la résolution de surcharge seulement si s est convertible en typename std:: common_type < Rep1, Rep2 > :: type et si Rep2 n'est pas une spécialisation de duration .
6) Convertit les deux durées vers leur type commun et divise le nombre de ticks de lhs après conversion par le nombre de ticks de rhs après conversion. Notez que la valeur de retour de cet opérateur n'est pas une durée.
7) Convertit la durée d en une durée dont le rep est le type commun entre Rep1 et Rep2 , et crée une durée dont le nombre de ticks est le reste de la division du nombre de ticks, après conversion, par s . Cette surcharge participe à la résolution de surcharge seulement si s est convertible en typename std:: common_type < Rep1, Rep2 > :: type et que Rep2 n'est pas une spécialisation de duration .
8) Convertit les deux durées en leur type commun et crée une durée dont le nombre de ticks est le reste de la division des nombres de ticks après conversion.

Table des matières

Paramètres

lhs - durée sur le côté gauche de l'opérateur
rhs - durée sur le côté droit de l'opérateur
d - l'argument de durée pour les opérateurs à arguments mixtes
s - argument non-durée pour les opérateurs à arguments mixtes

Valeur de retour

En supposant que CD soit le type de retour de la fonction et que CD < A, B > = std:: common_type < A, B > :: type , alors :

1) CD ( CD ( lhs ) . count ( ) + CD ( rhs ) . count ( ) )
**Note:** Le code C++ dans les balises ` ` n'a pas été traduit conformément aux instructions, car il contient des termes spécifiques au C++ et du code qui doit rester intact. Seul le numéro "1)" a été conservé tel quel, car il s'agit d'un élément de liste numérique qui ne nécessite pas de traduction.
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 ( ) (le type de retour de cet opérateur n'est pas une durée)
7) CD ( CD ( d ) . count ( ) % s )
8) CD ( CD ( lhs ) . count ( ) % CD ( rhs ) . count ( ) )

Exemple

Exécuter ce code 
#include <chrono>
#include <iostream>
int main()
{
    // Opérations arithmétiques simples :
    std::chrono::seconds s = std::chrono::hours(1)
                           + 2 * std::chrono::minutes(10)
                           + std::chrono::seconds(70) / 10;
    std::cout << "1 heure + 2*10 min + 70/10 sec = " << s << " (secondes)\n";
    using namespace std::chrono_literals;
    // Différence entre diviser une durée par un nombre
    // et diviser une durée par une autre durée :
    std::cout << "Diviser cela par 2 minutes donne "
              << s / 2min << '\n'
              << "Diviser cela par 2 donne "
              << (s / 2).count() << " secondes\n";
    // L'opérateur reste est utile pour déterminer où
    // dans un intervalle de temps se trouve cette durée particulière, par exemple
    // pour la décomposer en heures, minutes et secondes :
    std::cout << s << " (secondes) = "
              << std::chrono::duration_cast<std::chrono::hours>(
                 s) << " (heure) + "
              << std::chrono::duration_cast<std::chrono::minutes>(
                 s % 1h) << " (minutes) + "
              << std::chrono::duration_cast<std::chrono::seconds>(
                 s % 1min) << " (secondes)\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 << "Un photon voyage du Soleil à la Terre en "
              << t / 1min << " minutes " << t % 1min << " (secondes)\n";
}

Sortie : 

1 heure + 2*10 min + 70/10 sec = 4807s (secondes)
Diviser cela par 2 minutes donne 40
Diviser cela par 2 donne 2403 secondes
4807s (secondes) = 1h (heure) + 20min (minutes) + 7s (secondes)
Un photon voyage du Soleil à la Terre en 8 minutes 20s (secondes)

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 3050 C++11 convertibility constraint used non-const xvalue use const lvalues instead