date and time in C++ with code examples

In C++, working with date and time can be done using the <ctime> library for basic operations, and the <chrono> library (introduced in C++11) for high-resolution time and duration calculations.

These libraries provide functions and data structures to get the current time, manipulate dates and times, and format date/time output.

Basic Date and Time Functions with <ctime>

The <ctime> library provides simple functions for working with system time.

1. Getting the Current Date and Time

The time function gets the current time as a time_t object, which can then be formatted to a readable string using ctime.

#include <iostream>
#include <ctime>
using namespace std;

int main() {
    // Get current time
    time_t currentTime = time(0);

    // Convert to readable format
    char* dt = ctime(¤tTime);

    cout << "Current date and time: " << dt << endl;

    return 0;
}

Explanation:

• time(0) returns the current time in seconds since January 1, 1970 (Unix epoch).
• ctime converts this time to a human-readable format.

Output:

Current date and time: Tue Oct 25 10:00:00 2023

2. Breaking Down the Date and Time

The localtime function breaks down the time_t object into a tm structure, allowing access to individual date and time components.

#include <iostream>
#include <ctime>
using namespace std;

int main() {
    // Get current time
    time_t currentTime = time(0);
    tm* localTime = localtime(¤tTime);

    cout << "Year: " << 1900 + localTime->tm_year << endl;
    cout << "Month: " << 1 + localTime->tm_mon << endl;
    cout << "Day: " << localTime->tm_mday << endl;
    cout << "Hour: " << localTime->tm_hour << endl;
    cout << "Minute: " << localTime->tm_min << endl;
    cout << "Second: " << localTime->tm_sec << endl;

    return 0;
}

Explanation:

• tm_year, tm_mon, and other members of tm hold the respective year, month, day, hour, minute, and second.
• The year is offset by 1900, and months are 0-based (0 for January).

Output:

Year: 2023
Month: 10
Day: 25
Hour: 10
Minute: 15
Second: 30

3. Formatting Date and Time with strftime

The strftime function provides custom date and time formatting.

#include <iostream>
#include <ctime>
using namespace std;

int main() {
    // Get current time
    time_t currentTime = time(0);
    tm* localTime = localtime(¤tTime);

    // Custom date format
    char buffer[80];
    strftime(buffer, 80, "Today is %A, %B %d, %Y", localTime);
    cout << buffer << endl;

    return 0;
}

Explanation:

• strftime formats date and time according to a specified pattern.
  • %A is the full weekday name.
  • %B is the full month name.
  • %d, %Y are day and year respectively.

Output:

Today is Tuesday, October 25, 2023

4. Measuring Execution Time with <chrono>

The <chrono> library allows high-resolution time measurements. It’s useful for measuring the duration of code execution.

#include <iostream>
#include <chrono>
using namespace std;

int main() {
    // Start time
    auto start = chrono::high_resolution_clock::now();

    // Code to measure
    for (int i = 0; i < 1000000; ++i);

    // End time
    auto end = chrono::high_resolution_clock::now();

    // Calculate duration
    chrono::duration<double> duration = end - start;
    cout << "Execution time: " << duration.count() << " seconds" << endl;

    return 0;
}

Explanation:

• chrono::high_resolution_clock::now() gets the current time.
• duration.count() converts the duration to seconds.

Output (may vary based on system):

Execution time: 0.002345 seconds

5. Adding and Subtracting Time Durations

The <chrono> library allows you to manipulate time durations, like adding or subtracting days, hours, minutes, etc.

#include <iostream>
#include <chrono>
using namespace std;

int main() {
    // Current time
    auto now = chrono::system_clock::now();

    // Add 1 day to current time
    auto tomorrow = now + chrono::hours(24);
    
    // Subtract 30 minutes from current time
    auto halfHourEarlier = now - chrono::minutes(30);

    // Convert to time_t for output
    time_t now_t = chrono::system_clock::to_time_t(now);
    time_t tomorrow_t = chrono::system_clock::to_time_t(tomorrow);
    time_t earlier_t = chrono::system_clock::to_time_t(halfHourEarlier);

    cout << "Current time: " << ctime(&now_t);
    cout << "Tomorrow: " << ctime(&tomorrow_t);
    cout << "Half hour earlier: " << ctime(&earlier_t);

    return 0;
}

Explanation:

• chrono::hours(24) adds 24 hours (1 day) to now.
• chrono::minutes(30) subtracts 30 minutes.

Output:

Current time: Tue Oct 25 10:30:00 2023
Tomorrow: Wed Oct 26 10:30:00 2023
Half hour earlier: Tue Oct 25 10:00:00 2023

6. Calculating Days Between Dates

You can use std::chrono to calculate the difference in days between two dates.

#include <iostream>
#include <chrono>
using namespace std;
using namespace chrono;

int main() {
    system_clock::time_point today = system_clock::now();
    system_clock::time_point lastWeek = today - days(7);

    // Calculate the difference
    auto duration = duration_cast<days>(today - lastWeek);
    cout << "Days between today and last week: " << duration.count() << " days" << endl;

    return 0;
}

Explanation:

• today – lastWeek gives the duration between the two dates.
• duration_cast<days> converts it to a days object.

Output:

Days between today and last week: 7 days

7. Creating a Timer

Using <chrono> and a loop, you can implement a countdown timer.

#include <iostream>
#include <thread>
#include <chrono>
using namespace std;

void countdown(int seconds) {
    for (int i = seconds; i > 0; --i) {
        cout << "Time remaining: " << i << " seconds\r" << flush;
        this_thread::sleep_for(chrono::seconds(1));
    }
    cout << "\nTime's up!" << endl;
}

int main() {
    countdown(5);  // 5-second timer

    return 0;
}

Explanation:

• sleep_for(chrono::seconds(1)) pauses the program for 1 second between each countdown step.
• \r and flush allow the countdown to overwrite the previous line for a live countdown effect.

Output:

Time remaining: 5 seconds
Time remaining: 4 seconds
...
Time's up!

8. Converting a Custom Date to time_t

If you want to create a specific date and convert it to time_t, you can do so with the tm structure.

#include <iostream>
#include <ctime>
using namespace std;

int main() {
    tm customDate = {};
    customDate.tm_year = 2023 - 1900; // Year since 1900
    customDate.tm_mon = 9;            // October (0-based)
    customDate.tm_mday = 25;          // 25th day
    customDate.tm_hour = 10;          // 10 AM
    customDate.tm_min = 0;
    customDate.tm_sec = 0;

    time_t date = mktime(&customDate);
    cout << "Custom date and time: " << ctime(&date);

    return 0;
}

Explanation:

• mktime converts a tm structure to time_t.
• ctime outputs the custom date as a human-readable string.

Output:

Custom date and time: Tue Oct 25 10:00:00 2023

9. Measuring Time Intervals with std::chrono::steady_clock

steady_clock is a monotonic clock that’s unaffected by system clock changes, making it ideal for measuring elapsed time.

#include <iostream>
#include <chrono>
using namespace std;

int main() {
    auto start = chrono::steady_clock::now();

    // Code to measure
    for (int i = 0; i < 100000

0; ++i);

    auto end = chrono::steady_clock::now();
    auto duration = chrono::duration_cast<chrono::milliseconds>(end - start);
    cout << "Execution time: " << duration.count() << " milliseconds" << endl;

    return 0;
}

Explanation:

• steady_clock::now() captures the start and end time.
• duration_cast<chrono::milliseconds> converts the duration to milliseconds.

Output (varies based on system):

Execution time: 3 milliseconds

10. Getting the Epoch Time Using <chrono>

With <chrono>, you can get the epoch time (number of seconds since January 1, 1970).

#include <iostream>
#include <chrono>
using namespace std;

int main() {
    auto epoch = chrono::system_clock::now().time_since_epoch();
    auto seconds = chrono::duration_cast<chrono::seconds>(epoch);

    cout << "Epoch time: " << seconds.count() << " seconds since 1970-01-01" << endl;

    return 0;
}

Explanation:

• time_since_epoch() gets the time from the epoch.
• duration_cast<chrono::seconds> converts it to seconds.

Output:

Epoch time: 1698255600 seconds since 1970-01-01

Summary Table of Date and Time Functions

Key Takeaways

• <ctime> is suitable for basic date and time operations, while <chrono> provides more precision and flexibility for time intervals.
• Functions like time(), localtime(), and strftime() make it easy to access and format system time.
• Use chrono::high_resolution_clock for high-precision time measurement and chrono::steady_clock for consistent time intervals.
• Time manipulations (like adding days or hours) are easy with <chrono> and useful for implementing timers, clocks, and date calculations.