Punkty w czasie
Reprezentuj chwile w czasie
Punkty w czasie to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 2 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.
Czym jest punkt czasowy?
std::chrono::time_point reprezentuje konkretną chwilę mierzoną od epoki zegara. Łączy zegar z czasem trwania od tej epoki.
- Jest zwracany przez
clock::now(). - Odjęcie dwóch punktów czasowych daje czas trwania.
#include <iostream>
#include <chrono>
int main() {
using namespace std::chrono;
time_point<steady_clock> tp = steady_clock::now();
std::cout << "Captured a moment: " << (tp.time_since_epoch().count() != 0) << '\n';
return 0;
}time_since_epoch
Każdy punkt czasowy może określić odległość od epoki zegara za pomocą time_since_epoch(), która zwraca czas trwania.
#include <iostream>
#include <chrono>
int main() {
using namespace std::chrono;
auto tp = system_clock::now();
auto d = tp.time_since_epoch();
auto s = duration_cast<seconds>(d);
std::cout << "Positive epoch seconds: " << (s.count() > 0) << '\n';
return 0;
}Odejmowanie punktów czasowych
Odjęcie jednego punktu czasowego od drugiego daje czas trwania, czyli czas, który upłynął między dwiema chwilami.
#include <iostream>
#include <chrono>
int main() {
using namespace std::chrono;
auto a = steady_clock::now();
auto b = steady_clock::now();
auto diff = b - a;
std::cout << "Elapsed ns is non-negative: " << (diff.count() >= 0) << '\n';
return 0;
}Dodawanie czasu trwania
Dodanie czasu trwania do punktu czasowego tworzy nowy punkt czasowy w przyszłości (a odejmowanie — w przeszłości). W ten sposób oblicza się terminy.
#include <iostream>
#include <chrono>
int main() {
using namespace std::chrono;
using namespace std::chrono_literals;
auto now = steady_clock::now();
auto deadline = now + 10s;
std::cout << "Deadline is after now: " << std::boolalpha << (deadline > now) << '\n';
return 0;
}Porównywanie punktów czasowych
Punkty czasowe pochodzące z tego samego zegara obsługują wszystkie operatory porównania, dzięki czemu można sprawdzić, czy jedna chwila przypada przed inną, czy po niej.
#include <iostream>
#include <chrono>
int main() {
using namespace std::chrono;
auto first = steady_clock::now();
auto second = steady_clock::now();
std::cout << std::boolalpha << (first <= second) << '\n';
return 0;
}Punkty czasowe zależne od zegara
Punkt czasowy jest powiązany z typem swojego zegara. Nie można bezpośrednio porównywać punktu czasowego system_clock z punktem czasowym steady_clock, ponieważ ich epoki są różne.
#include <iostream>
#include <chrono>
int main() {
using namespace std::chrono;
system_clock::time_point sys = system_clock::now();
steady_clock::time_point mono = steady_clock::now();
std::cout << "Both captured: " << ((sys.time_since_epoch().count() != 0) && (mono.time_since_epoch().count() != 0)) << '\n';
return 0;
}Konwertowanie na time_t
system_clock::to_time_t przekształca kalendarzowy punkt czasowy na należący do stylu C typ time_t, który można sformatować do wyświetlenia.
#include <iostream>
#include <chrono>
#include <ctime>
int main() {
using namespace std::chrono;
auto tp = system_clock::now();
std::time_t t = system_clock::to_time_t(tp);
std::cout << "time_t is positive: " << (t > 0) << '\n';
return 0;
}from_time_t
Odwrotna operacja, system_clock::from_time_t, tworzy punkt czasowy na podstawie wartości time_t, takiej jak zapisany znacznik czasu.
#include <iostream>
#include <chrono>
#include <ctime>
int main() {
using namespace std::chrono;
std::time_t t = 1000000000;
auto tp = system_clock::from_time_t(t);
auto back = system_clock::to_time_t(tp);
std::cout << "Round trip ok: " << std::boolalpha << (back == t) << '\n';
return 0;
}Obliczanie terminu
Popularny wzorzec wygląda następująco: należy pobrać wartość now(), dodać czas trwania limitu, a następnie porównać ją z nową wartością now(), aby sprawdzić, czy termin już minął.
#include <iostream>
#include <chrono>
int main() {
using namespace std::chrono;
using namespace std::chrono_literals;
auto deadline = steady_clock::now() + 0ms;
auto current = steady_clock::now();
bool expired = current >= deadline;
std::cout << "Expired: " << std::boolalpha << expired << '\n';
return 0;
}Precyzja punktu czasowego
Precyzja punktu czasowego odpowiada typowi czasu trwania jego zegara. Punkt czasowy można przekonwertować na mniej dokładną jednostkę za pomocą time_point_cast.
#include <iostream>
#include <chrono>
int main() {
using namespace std::chrono;
auto tp = system_clock::now();
auto secs_tp = time_point_cast<seconds>(tp);
std::cout << "Cast preserved sign: " << (secs_tp.time_since_epoch().count() > 0) << '\n';
return 0;
}Przechowywanie znaczników czasu
Aby zachować chwilę w czasie, należy przekonwertować ją na liczbę sekund od epoki, zapisać liczbę całkowitą, a następnie w razie potrzeby odtworzyć punkt czasowy.
#include <iostream>
#include <chrono>
int main() {
using namespace std::chrono;
auto tp = system_clock::now();
long long stored = duration_cast<seconds>(tp.time_since_epoch()).count();
std::cout << "Stored value usable: " << (stored > 0) << '\n';
return 0;
}Szybkie sprawdzenie
Proszę sprawdzić swoją wiedzę na temat działań arytmetycznych na punktach czasowych.
Podsumowanie
Dowiedzieli się Państwo, że time_point:
- oznacza konkretną chwilę względem epoki zegara
- zwraca swoje przesunięcie za pomocą
time_since_epoch() - obsługuje dodawanie i odejmowanie czasów trwania oraz porównywanie
- można konwertować na
time_ti z niego konwertować w celu wyświetlania i przechowywania
W następnym kroku użyją Państwo tych narzędzi do testowania i mierzenia wydajności kodu.
Często zadawane pytania
Czy lekcja „Punkty w czasie” jest bezpłatna?
Tak — pełny tekst „Punkty w czasie” 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 „Punkty w czasie”?
Reprezentuj chwile w czasie Ć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 2 z 4.
Ile czasu zajmuje lekcja „Punkty w czasie”?
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.