std::chrono:: duration_cast

Convertit un std::chrono::duration en une durée de type différent ToDuration .

La fonction ne participe à la résolution de surcharge que si ToDuration est une spécialisation de std::chrono::duration .

Soit

• ToRep soit typename ToDuration :: rep ,
• ToPeriod soit typename ToDuration :: period ,
• CF soit std:: ratio_divide < Period, ToPeriod > ,
• CR soit std:: common_type < Rep, ToRep, std:: intmax_t > :: type ,
• cr_count soit static_cast < CR > ( d. count ( ) ) ,
• cr_num soit static_cast < CR > ( CF :: num ) , et
• cr_den soit static_cast < CR > ( CF :: den ) ,

le résultat est :

Paramètres

Valeur de retour

d converti en une durée de type ToDuration .

Notes

Aucune conversion implicite n'est utilisée. Les multiplications et divisions sont évitées autant que possible, s'il est connu à la compilation qu'un ou plusieurs paramètres sont 1 . Les calculs sont effectués dans le type le plus large disponible et convertis, comme par static_cast , vers le type de résultat uniquement une fois terminés.

La conversion entre des durées entières où la période source est exactement divisible par la période cible (par exemple, des heures en minutes) ou entre des durées à virgule flottante peut être effectuée avec des conversions ordinaires ou implicitement via les std::chrono::duration constructeurs , aucun duration_cast n'est nécessaire.

La conversion d'une durée en virgule flottante vers une durée entière est sujette à un comportement indéfini lorsque la valeur en virgule flottante est NaN, infinie, ou trop grande pour être représentable par le type entier cible. Sinon, la conversion vers une durée entière est sujette à la troncation comme avec toute static_cast vers un type entier.

Exemple

#include <chrono>
#include <iostream>
#include <ratio>
#include <thread>
void f()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}
int main()
{
    const auto t1 = std::chrono::high_resolution_clock::now();
    f();
    const auto t2 = std::chrono::high_resolution_clock::now();
    // floating-point duration: no duration_cast needed
    const std::chrono::duration<double, std::milli> fp_ms = t2 - t1;
    // integral duration: requires duration_cast
    const auto int_ms = std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1);
    // converting integral duration to integral duration of
    // shorter divisible time unit: no duration_cast needed
    const std::chrono::duration<long, std::micro> int_usec = int_ms;
    std::cout << "f() took " << fp_ms << ", or "
              << int_ms << " (whole milliseconds), or "
              << int_usec << " (whole microseconds)\n";
}

f() took 1000.14ms, or 1000ms (whole milliseconds), or 1000000us (whole microseconds)

Voir aussi