C++ Academy · Lekcja

Czasy trwania i zegary

Mierz odstępy czasu

Czasy trwania i zegary to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C++ Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C++ Academy zawiera 4 lekcji w sumie.

Dlaczego <chrono>?

Biblioteka <chrono> zapewnia językowi C++ bezpieczny typowo sposób pracy z czasem. Zamiast surowych liczb całkowitych używa się silnie typowanych czasów trwania i punktów czasowych, dzięki czemu kompilator wykrywa pomyłki jednostek.

Koniec z myleniem sekund i milisekund.
Jednostki są częścią systemu typów.

#include <iostream>
#include <chrono>

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

Czym jest czas trwania?

std::chrono::duration reprezentuje odcinek czasu. Przechowuje liczbę taktów oraz współczynnik opisujący okres taktu. Wstępnie zdefiniowane aliasy obejmują typowe jednostki.

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;
}

Literały czasu trwania

Przestrzeń nazw std::chrono_literals umożliwia zapisywanie czasów trwania z przyrostkami, takimi jak 5s lub 200ms, dzięki czemu kod przypomina zwykły język.

#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;
}

Konwertowanie czasów trwania

duration_cast konwertuje wartości między jednostkami. Rzutowanie z dokładniejszej jednostki na mniej dokładną obcina wynik, więc 1500 ms staje się 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;
}

Działania arytmetyczne na czasach trwania

Czasy trwania obsługują operatory +, -, * i /. Łączenie jednostek automatycznie podnosi wynik do dokładniejszej wspólnej jednostki.

#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;
}

Czasy trwania zmiennoprzecinkowe

Podczas konwersji można użyć reprezentacji zmiennoprzecinkowej, aby zachować wartości ułamkowe i uniknąć obcinania charakterystycznego dla całkowitych czasów trwania.

#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;
}

Czym jest zegar?

Zegar dostarcza bieżący czas. Biblioteka standardowa udostępnia trzy zegary:

system_clock — czas zegarowy
steady_clock — nigdy się nie cofa, idealny do pomiaru czasu
high_resolution_clock — dostępny takt o najwyższej rozdzielczości

#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 śledzi rzeczywisty czas kalendarzowy i można go konwertować na time_t w celu wyświetlania. Może przeskoczyć, jeśli zegar systemowy zostanie skorygowany.

#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 jest monotoniczny: porusza się wyłącznie do przodu ze stałą szybkością. Należy używać go zawsze podczas mierzenia czasu, a nie 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;
}

Rozdzielczość zegara

Każdy zegar udostępnia swoją właściwość period jako współczynnik znany w czasie kompilacji. W czasie kompilacji można również sprawdzić, czy zegar jest stabilny.

#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;
}

Łączenie elementów

Należy połączyć zegary i czasy trwania: odczytać dwa punkty czasowe i obliczyć różnicę jako czas trwania w wybranej jednostce.

#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;
}

Szybkie sprawdzenie

Proszę sprawdzić swoją wiedzę na temat wyboru zegara do pomiaru czasu.

Podsumowanie

Dowiedzieli się Państwo, że biblioteka <chrono> udostępnia:

czasy trwania — bezpieczne typowo odcinki czasu z literałami, takimi jak 5s
duration_cast do konwertowania jednostek (obcina wartości całkowite)
zegary — system_clock, steady_clock, high_resolution_clock
należy używać steady_clock do mierzenia odstępów czasu

W następnym kroku przedstawią Państwo konkretne chwile w czasie za pomocą punktów czasowych.

Często zadawane pytania

Czy lekcja „Czasy trwania i zegary” jest bezpłatna?

Tak — pełny tekst „Czasy trwania i zegary” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C++ Academy, przejdź na CoddyKit PRO. Kurs C++ Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Czasy trwania i zegary”?

Mierz odstępy czasu Ćwiczysz C++ Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C++ Academy?

Nie wymagamy żadnego doświadczenia. C++ Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Czasy trwania i zegary”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C++ Academy?

Tak. Każda lekcja C++ Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C++ Academy