Zeitpunkte
Zeitpunkte darstellen
Zeitpunkte ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.
Was ist ein Zeitpunkt?
Ein std::chrono::time_point stellt einen bestimmten Zeitpunkt dar, gemessen ab der Epoche einer Uhr. Er verbindet eine Uhr mit einer Zeitdauer seit dieser Epoche.
- Wird von
clock::now()zurückgegeben. - Das Subtrahieren zweier Zeitpunkte ergibt eine Zeitdauer.
#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
Jeder Zeitpunkt kann mit time_since_epoch() seinen Abstand zur Epoche der Uhr melden. Die Funktion gibt eine Zeitdauer zurück.
#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;
}Zeitpunkte subtrahieren
Wenn Sie einen Zeitpunkt von einem anderen subtrahieren, erhalten Sie eine Zeitdauer, also die verstrichene Zeit zwischen den beiden Zeitpunkten.
#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;
}Eine Zeitdauer addieren
Das Addieren einer Zeitdauer zu einem Zeitpunkt erzeugt einen neuen Zeitpunkt in der Zukunft (bei einer Subtraktion in der Vergangenheit). So berechnen Sie Deadlines.
#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;
}Zeitpunkte vergleichen
Zeitpunkte derselben Uhr unterstützen alle Vergleichsoperatoren. Damit können Sie prüfen, ob ein Zeitpunkt vor oder nach einem anderen liegt.
#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;
}Uhrabhängige Zeitpunkte
Ein Zeitpunkt ist an den Typ seiner Uhr gebunden. Sie können einen Zeitpunkt von system_clock nicht direkt mit einem von steady_clock vergleichen, da ihre Epochen unterschiedlich sind.
#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;
}In time_t konvertieren
system_clock::to_time_t wandelt einen Kalenderzeitpunkt in einen C-artigen time_t um, den Sie für die Anzeige im für Menschen lesbaren Format formatieren können.
#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
Das Gegenstück system_clock::from_time_t erstellt aus einem time_t-Wert, etwa einem gespeicherten Zeitstempel, einen Zeitpunkt.
#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;
}Eine Deadline berechnen
Ein häufig verwendetes Muster: Erfassen Sie now(), addieren Sie eine Zeitdauer für das Timeout und vergleichen Sie später mit einem neuen now(), um festzustellen, ob die Deadline überschritten wurde.
#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;
}Genauigkeit von Zeitpunkten
Die Genauigkeit eines Zeitpunkts entspricht dem Zeitdauertyp seiner Uhr. Sie können einen Zeitpunkt mit time_point_cast in eine gröbere Einheit umwandeln.
#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;
}Zeitstempel speichern
Um einen Zeitpunkt dauerhaft zu speichern, wandeln Sie ihn in eine Anzahl von Sekunden seit der Epoche um, speichern Sie die Ganzzahl und stellen Sie den Zeitpunkt bei Bedarf später wieder her.
#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;
}Kurze Überprüfung
Testen Sie Ihr Verständnis der Arithmetik mit Zeitpunkten.
Zusammenfassung
Sie haben gelernt, dass ein time_point:
- einen bestimmten Zeitpunkt relativ zur Epoche einer Uhr markiert
- seinen Abstand mit
time_since_epoch()liefert - das Addieren und Subtrahieren von Zeitdauern sowie Vergleiche unterstützt
- sich für die Anzeige und Speicherung in
time_tumwandeln und daraus wiederherstellen lässt
Als Nächstes verwenden Sie diese Werkzeuge, um Code zu benchmarken und seine Leistung zu messen.
Häufig gestellte Fragen
Ist die Lektion „Zeitpunkte“ kostenlos?
Ja — der vollständige Text von „Zeitpunkte“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Zeitpunkte“?
Zeitpunkte darstellen Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C++ Academy zu starten?
Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Zeitpunkte“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?
Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.