C++ Academy · Lektion

Dauern und Uhren

Zeitintervalle messen

Dauern und Uhren ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Warum <chrono>?

Die Bibliothek <chrono> bietet C++ eine typsichere Möglichkeit, mit Zeit zu arbeiten. Statt einfacher Ganzzahlen verwenden Sie stark typisierte Zeitdauern und Zeitpunkte, sodass der Compiler Fehler bei Einheiten erkennen kann.

Keine Verwechslung von Sekunden und Millisekunden mehr.
Einheiten sind Bestandteil des Typsystems.

#include <iostream>
#include <chrono>

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

Was ist eine Zeitdauer?

Eine std::chrono::duration stellt eine Zeitspanne dar. Sie speichert eine Anzahl von Ticks sowie ein Verhältnis, das die Tick-Periode beschreibt. Vordefinierte Aliase decken gängige Einheiten ab.

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

Literale für Zeitdauern

Mit dem Namensraum std::chrono_literals können Sie Zeitdauern mit Suffixen wie 5s oder 200ms schreiben. Dadurch liest sich der Code wie normale Sprache.

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

Zeitdauern konvertieren

duration_cast konvertiert zwischen Einheiten. Die Umwandlung von einer feineren in eine gröbere Einheit schneidet Nachkommastellen ab, sodass aus 1500 ms 1 s wird.

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

Arithmetik mit Zeitdauern

Zeitdauern unterstützen +, -, * und /. Beim Mischen von Einheiten wird automatisch die feinere gemeinsame Einheit verwendet.

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

Zeitdauern mit Gleitkommawerten

Sie können eine Gleitkommadarstellung verwenden, um bei Konvertierungen Bruchteile zu erhalten und das Abschneiden bei ganzzahligen Zeitdauern zu vermeiden.

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

Was ist eine Uhr?

Eine Uhr liefert die aktuelle Zeit. Die Standardbibliothek bietet drei Uhren:

system_clock — bürgerliche Zeit
steady_clock — läuft niemals rückwärts und eignet sich ideal für Zeitmessungen
high_resolution_clock — die feinste verfügbare Tick-Auflösung

#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 verfolgt die reale Kalenderzeit und kann für die Anzeige in einen time_t konvertiert werden. Sie kann springen, wenn die Systemuhr angepasst wird.

#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 ist monoton: Sie bewegt sich nur mit konstanter Rate vorwärts. Verwenden Sie sie immer, wenn Sie verstrichene Zeit messen, und niemals 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;
}

Uhrauflösung

Jede Uhr stellt ihre period als Verhältnis zur Compilezeit bereit. Sie können zur Compilezeit auch prüfen, ob eine Uhr stetig läuft.

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

Alles zusammenführen

Kombinieren Sie Uhren und Zeitdauern: Lesen Sie zwei Zeitpunkte aus und berechnen Sie ihre Differenz als Zeitdauer in der von Ihnen gewählten Einheit.

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

Kurze Überprüfung

Testen Sie Ihr Verständnis dafür, welche Uhr Sie für Zeitmessungen verwenden sollten.

Zusammenfassung

Sie haben gelernt, dass <chrono> Folgendes bereitstellt:

Zeitdauern — typsichere Zeitspannen mit Literalen wie 5s
duration_cast zum Konvertieren von Einheiten (bei Ganzzahlen werden Nachkommastellen abgeschnitten)
Uhren — system_clock, steady_clock, high_resolution_clock
Verwenden Sie steady_clock zum Messen von Zeitintervallen

Als Nächstes stellen Sie bestimmte Zeitpunkte mit time points dar.

Häufig gestellte Fragen

Ist die Lektion „Dauern und Uhren“ kostenlos?

Ja — der vollständige Text von „Dauern und Uhren“ 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 „Dauern und Uhren“?

Zeitintervalle messen 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 1 von 4.

Wie lange dauert die Lektion „Dauern und Uhren“?

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.

Alle Lektionen in diesem Kurs

← Zurück zu C++ Academy