C++ Academy · Lezione

Durate e orologi

Misurare intervalli di tempo

Durate e orologi è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Perché <chrono>?

La libreria <chrono> offre a C++ un modo sicuro dal punto di vista dei tipi per lavorare con il tempo. Invece di interi privi di contesto, si utilizzano durate e punti temporali fortemente tipizzati, così il compilatore può rilevare gli errori nelle unità di misura.

Niente più confusione tra secondi e millisecondi.
Le unità fanno parte del sistema dei tipi.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    seconds s{5};
    std::cout << "Duration: " << s.count() << " seconds\n";
    return 0;
}

Che cos'è una durata

Una std::chrono::duration rappresenta un intervallo di tempo. Memorizza un conteggio di tick e un rapporto che descrive il periodo del tick. Gli alias predefiniti coprono le unità più comuni.

hours, minutes, seconds
milliseconds, microseconds, nanoseconds

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    milliseconds ms{1500};
    std::cout << ms.count() << " ms\n";
    return 0;
}

Letterali per le durate

Lo spazio dei nomi std::chrono_literals consente di scrivere le durate con suffissi come 5s o 200ms, rendendo il codice simile al linguaggio naturale.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono_literals;
    auto wait = 3s;
    auto blink = 250ms;
    std::cout << wait.count() << "s, " << blink.count() << "ms\n";
    return 0;
}

Conversione delle durate

duration_cast converte le unità. La conversione da un'unità più precisa a una meno precisa tronca il valore, quindi 1500 ms diventano 1 s.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    milliseconds ms{1500};
    seconds s = duration_cast<seconds>(ms);
    std::cout << s.count() << " whole seconds\n";
    return 0;
}

Aritmetica sulle durate

Le durate supportano +, -, * e /. Combinando unità diverse, il risultato viene automaticamente promosso all'unità comune più precisa.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto total = minutes{2} + seconds{30};
    std::cout << total.count() << " seconds total\n";
    return 0;
}

Durate in virgola mobile

È possibile utilizzare una rappresentazione in virgola mobile per conservare i valori frazionari durante le conversioni ed evitare il troncamento delle durate intere.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    milliseconds ms{1500};
    duration<double> secs = ms;
    std::cout << secs.count() << " seconds\n";
    return 0;
}

Che cos'è un orologio

Un orologio fornisce l'ora corrente. La libreria standard ne offre tre:

system_clock — ora civile
steady_clock — non torna mai indietro, ideale per le misurazioni temporali
high_resolution_clock — tick con la granularità più fine disponibile

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto now = steady_clock::now();
    std::cout << "Got a time point: " << (now.time_since_epoch().count() > 0) << '\n';
    return 0;
}

system_clock

system_clock tiene traccia dell'ora civile reale e può essere convertito in un time_t per la visualizzazione. Può fare salti se l'orologio del sistema viene regolato.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto tp = system_clock::now();
    auto secs = duration_cast<seconds>(tp.time_since_epoch());
    std::cout << "Seconds since epoch is positive: " << (secs.count() > 0) << '\n';
    return 0;
}

steady_clock

steady_clock è monotono: avanza soltanto a velocità costante. Lo utilizzi ogni volta che misura il tempo trascorso, mai system_clock.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto a = steady_clock::now();
    auto b = steady_clock::now();
    std::cout << "Monotonic: " << std::boolalpha << (b >= a) << '\n';
    return 0;
}

Risoluzione dell'orologio

Ogni orologio espone il proprio period come rapporto determinato in fase di compilazione. È inoltre possibile verificare in fase di compilazione se un orologio è stabile.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    std::cout << "steady_clock is_steady: " << std::boolalpha << steady_clock::is_steady << '\n';
    std::cout << "system_clock is_steady: " << system_clock::is_steady << '\n';
    return 0;
}

Mettere tutto insieme

Combini orologi e durate: legga due punti temporali e calcoli la differenza come una durata nell'unità scelta.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto start = steady_clock::now();
    long sum = 0;
    for (int i = 0; i < 1000000; ++i) sum += i;
    auto end = steady_clock::now();
    auto us = duration_cast<microseconds>(end - start);
    std::cout << "Loop took at least 0 us: " << (us.count() >= 0) << '\n';
    return 0;
}

Verifica rapida

Verifichi la Sua comprensione di quale orologio utilizzare per le misurazioni temporali.

Riepilogo

Ha imparato che <chrono> fornisce:

durate — intervalli di tempo sicuri dal punto di vista dei tipi, con letterali come 5s
duration_cast per convertire le unità (tronca i valori interi)
orologi — system_clock, steady_clock, high_resolution_clock
utilizzi steady_clock per misurare gli intervalli

Ora rappresenterà momenti specifici nel tempo con i punti temporali.

Domande Frequenti

La lezione «Durate e orologi» è gratuita?

Sì — il testo completo di «Durate e orologi» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Durate e orologi»?

Misurare intervalli di tempo Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Durate e orologi»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C++ Academy