Namespace
Varianti

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

Da cppreference.com.
< cpp‎ | chrono‎ | duration

 
 
Utilità libreria
Tipo di supporto (basic types, RTTI, type traits)
Gestione della memoria dinamica
La gestione degli errori
Programma di utilità
Funzioni variadic
Data e ora
Funzione oggetti
initializer_list(C++11)
bitset
hash(C++11)
Gli operatori relazionali
Original:
Relational operators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
rel_ops::operator!=
rel_ops::operator>
rel_ops::operator<=
rel_ops::operator>=
Coppie e tuple
Original:
Pairs and tuples
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
pair
tuple(C++11)
piecewise_construct_t(C++11)
piecewise_construct(C++11)
Swap, in avanti e spostare
Original:
Swap, forward and move
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
swap
forward(C++11)
move(C++11)
move_if_noexcept(C++11)
declval(C++11)
 
 
std::chrono::duration
Membri funzioni
Original:
Member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
duration::duration
duration::operator=
duration::count
duration::zero
duration::min
duration::max
duration::operator+
duration::operator-
duration::operator++
duration::operator--
duration::operator+=
duration::operator-=
duration::operator*=
duration::operator/=
duration::operator%=
Non membri funzioni
Original:
Non-member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
common_type
operator+
operator-
operator*
operator/
operator%
operator==
operator!=
operator<
operator<=
operator>
operator>=
duration_cast
Helper classi
Original:
Helper classes
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
treat_as_floating_point
duration_values
 
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)
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)
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)
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)
template< class Rep1, class Period, class Rep2 >

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

                         const Rep2& s );
(5)
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)
template< class Rep1, class Period, class Rep2 >

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

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

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

                     const duration<Rep2,Period2>& rhs );
(8)
Esegue operazioni aritmetiche di base tra due durate o tra una durata ed un conteggio.
Original:
Performs basic arithmetic operations between two durations or between a duration and a tick count.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
Converte i due durate al loro tipo comune e crea una durata cui tick count è la somma dei conteggi di graduazione dopo la conversione.
Original:
Converts the two durations to their common type and creates a duration whose tick count is the sum of the tick counts after conversion.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
Converte le due durate al loro tipo comune e crea una durata il cui tick count è il numero di segni di graduazione rhs sottratti dal numero di segni di graduazione lhs dopo la conversione.
Original:
Converts the two durations to their common type and creates a duration whose tick count is the rhs number of ticks subtracted from the lhs number of ticks after conversion.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3-4)
Converte il d durata di un rep cui è il tipo comune tra Rep1 e Rep2, multipli e il numero di tick dopo la conversione da s.
Original:
Converts the duration d to one whose rep is the common type between Rep1 and Rep2, and multiples the number of ticks after conversion by s.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
5)
Converte il d durata di un rep cui è il tipo comune tra Rep1 e Rep2, e divide il numero di tick dopo la conversione da s
Original:
Converts the duration d to one whose rep is the common type between Rep1 and Rep2, and divides the number of ticks after conversion by s
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
6)
Converte le due durate al loro tipo comune e divide il conteggio di lhs dopo la conversione dal conteggio di rhs dopo la conversione. Si noti che il valore di ritorno di questo operatore non è una durata.
Original:
Converts the two durations to their common type and divides the tick count of lhs after conversion by the tick count of rhs after conversion. Note that the return value of this operator is not a duration.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
7)
Converte il d durata di un rep cui è il tipo comune tra Rep1 e Rep2, e crea una durata la cui zecca conteggio è il resto della divisione del conteggio, dopo la conversione, da s.
Original:
Converts the duration d to one whose rep is the common type between Rep1 and Rep2, and creates a duration whose tick count is the remainder of the division of the tick count, after conversion, by s.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
8)
Converte i due durate al loro tipo comune e crea una durata cui tick count è il resto dei conteggi di graduazione dopo la conversione.
Original:
Converts the two durations to their common type and creates a duration whose tick count is the remainder of the tick counts after conversion.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifica] Parametri

lhs -
durata sulla sinistra dell'operatore
Original:
duration on the left-hand side of the operator
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
rhs -
durata sulla destra dell'operatore
Original:
duration on the right-hand side of the operator
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
d -
l'argomento durata mista argomento operatori
Original:
the duration argument for mixed-argument operators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
s -
tick contare argomento per argomento mista operatori
Original:
tick count argument for mixed-argument operators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifica] Valore di ritorno

Supponendo che CD è il tipo di ritorno della funzione e CR<A, B> = std::common_type<A, B>::type, quindi:
Original:
Assuming that CD is the function return type and CR<A, B> = std::common_type<A, B>::type, then:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
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() (il tipo restituito di questo operatore non è durata)
Original:
CD(lhs).count() / CD(rhs).count() (the return type of this operator is not a duration)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
7) CD(CD(d).count() % s)
8) CD(CD(lhs).count() % CD(rhs).count())


[modifica] Esempio

#include <chrono>
#include <iostream>
int main()
{
    // simple arithmetic
    std::chrono::seconds s = std::chrono::hours(1) 
                             + 2*std::chrono::minutes(10)
                             + std::chrono::seconds(70)/10;
 
    std::cout << "1 hour + 2*10 min + 70/10 sec = " << s.count() << " seconds\n";
 
    // difference between dividing a duration by a number
    // and dividing a duration by another duration
    std::cout << "Dividing that by 2 minutes gives "
              << s / std::chrono::minutes(2) << '\n';
    std::cout << "Dividing that by 2 gives "
              << (s / 2).count() << " sconds\n";
 
   // the remainder operator is useful in determining where in a time
   // frame is this particular duration, e.g. to break it down into hours,
   // minutes, and seconds:
   std::cout << s.count() << " seconds is "
             << std::chrono::duration_cast<std::chrono::hours>(
                    s
                ).count() << " hours, "
             << std::chrono::duration_cast<std::chrono::minutes>(
                    s % std::chrono::hours(1)
                ).count() << " minutes, "
             << std::chrono::duration_cast<std::chrono::seconds>(
                    s % std::chrono::minutes(1)
                ).count() << " seconds\n";
}

Output:

1 hour + 2*10 min + 70/10 sec = 4807 seconds
Dividing that by 2 minutes gives 40
Dividing that by 2 gives 2403 sconds
4807 seconds is 1 hours, 20 minutes, 7 seconds