How to get Epoch/UNIX timestamps in C++

In C++, getting Epoch timestamps is straightforward, and there are several methods to accomplish this task. This article explores different ways to get Epoch timestamps in C++ and provides practical use cases.

Using the std::chrono Library

The std::chrono library in C++ provides tools for working with time. To obtain the current Epoch timestamp, you can use the std::chrono::system_clock and std::chrono::time_point classes.

#include <iostream>
#include <chrono>

int main() {
    auto current_time = std::chrono::system_clock::now();
    auto duration = current_time.time_since_epoch();
    auto epoch_time = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
    
    std::cout << "Current Epoch timestamp: " << epoch_time << std::endl;
    return 0;
}

This code snippet utilizes the std::chrono library to fetch the current Epoch timestamp. It retrieves the current time in std::chrono::system_clock::now(), calculates the duration since the epoch, and then converts it to seconds to obtain the Epoch timestamp.

Use Case 1: Logging timestamps

#include <iostream>
#include <chrono>

int main() {
    auto current_time = std::chrono::system_clock::now();
    auto duration = current_time.time_since_epoch();
    auto epoch_time = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
    
    std::string data = "Sensor data reading...";
    std::cout << data << " - timestamp: " << epoch_time << std::endl;
    
    return 0;
}

In this example, the C++ code is adapted for logging data with timestamps. It first obtains the current Epoch timestamp and then combines it with sensor data for logging.

Use Case 2: Time Duration Calculation

#include <iostream>
#include <chrono>

int main() {
    auto start_time = std::chrono::system_clock::now();
    
    // Perform a task or operation
    
    auto end_time = std::chrono::system_clock::now();
    auto duration = end_time - start_time;
    auto time_elapsed = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
    
    std::cout << "Time taken: " << time_elapsed << " seconds" << std::endl;
    
    return 0;
}

This use case demonstrates how to measure the time taken for a task. It records the start and end times and calculates the time elapsed by subtracting them. The result is displayed in seconds.

Using the time Function

In addition to the std::chrono library, C++ also provides the traditional C library function time to fetch the current Epoch timestamp. This function returns the timestamp as an integer.

#include <iostream>
#include <ctime>

int main() {
    std::time_t epoch_time = std::time(nullptr);
    std::cout << "Current Epoch timestamp: " << epoch_time << std::endl;
    return 0;
}

This code snippet utilizes the time function to obtain the current Epoch timestamp. The function returns the timestamp as an integer.

Use Case 3: Expiry timestamp for Cache

#include <iostream>
#include <ctime>

int main() {
    std::time_t epoch_time = std::time(nullptr);
    
    std::string cache_key = "cached_data";
    std::time_t expiry_time = epoch_time + 600; // 10 minutes from now
    
    std::cout << "Cached data that expires at " << expiry_time << std::endl;
    
    if (epoch_time > expiry_time) {
        std::cout << "Cache expired. Recaching data..." << std::endl;
        // Re-cache the data
    }
    
    return 0;
}

In this example, the C++ code calculates the expiry time for cache data. It sets the cache entry to expire in 10 minutes from the current time and then checks if the cache has expired.

Use Case 4: Event Scheduling

#include <iostream>
#include <ctime>
#include <thread>
#include <chrono>

int main() {
    std::time_t epoch_time = std::time(nullptr);
    std::time_t event_time = epoch_time + 3600; // 1 hour from now
    
    while (true) {
        std::time_t current_time = std::time(nullptr);
        if (current_time >= event_time) {
            std::cout << "Event occurred!" << std::endl;
            break;
        }
        else {
            std::this_thread::sleep_for(std::chrono::minutes(1)); // Check every minute
        }
    }
    
    return 0;
}

This use case demonstrates how to schedule an event to occur in the future. The C++ code adds 3600 seconds (1 hour) to the current time to set the event time and continuously checks for its occurrence.

These code examples illustrate how to get Epoch/UNIX timestamps in C++ and showcase their applications in practical scenarios. Whether you need to log data with timestamps, calculate time durations, set cache expiry times, or schedule events, Epoch timestamps are versatile tools in C++ for precise time-related operations.