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

<metanoindex/>

 

C++

Linguaggio

Concetti

Libreria di Utilità

Stringhe

Contenitori

Algoritmi

Iteratori

Libreria matematca

Input/output

Localizzazione

Espressioni regolari (C++11)

Operazioni atomicche (C++11)

Multithreading (C++11)

 

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)

 

Data e ora utilità

time_point (C++11)

duration (C++11)

system_clock (C++11)

steady_clock (C++11)

high_resolution_clock (C++11)

C-stile di data e ora

 

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

 

<tbody> </tbody>

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.

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.

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

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