Lấy thời gian hiện tại trong C++ như nào?

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

int main() {
    // Lấy thời gian hiện tại dưới dạng số giây kể từ epoch
    time_t now = time(0);
    
    // Chuyển đổi sang dạng chuỗi dễ đọc
    char* dt = ctime(&now);
    cout << "Current date time: " << dt;
    
    return 0;
}

// Current date time: Sun Apr  6 14:29:05 2025

#include <iostream>
#include <ctime>
#include <iomanip> // Cho setfill và setw
using namespace std;

int main() {
    // Lấy thời gian hiện tại
    time_t now = time(0);
    
    // Chuyển đổi sang dạng local time
    tm* ltm = localtime(&now);
    
    // In từng thành phần của thời gian với định dạng đẹp
    cout << "Date: " << setfill('0') << setw(2) << ltm->tm_mday << "/"
         << setfill('0') << setw(2) << (1 + ltm->tm_mon) << "/"
         << (1900 + ltm->tm_year) << endl;
    
    cout << "Time: " << setfill('0') << setw(2) << ltm->tm_hour << ":"
         << setfill('0') << setw(2) << ltm->tm_min << ":"
         << setfill('0') << setw(2) << ltm->tm_sec << endl;
    
    // Thông tin về ngày trong tuần
    string weekdays[] = {"Sunday", "Monday", "Tuesday", "Wednesday", 
                         "Thursday", "Friday", "Saturday"};
    cout << "Day of week: " << weekdays[ltm->tm_wday] << endl;
    
    // Ngày thứ bao nhiêu trong năm (1-366)
    cout << "Day of year: " << ltm->tm_yday + 1 << endl;
    
    return 0;
}

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

int main() {
    time_t now = time(0);
    
    // 1. Từ time_t sang chuỗi
    char* dt = ctime(&now);
    cout << "ctime(): " << dt;
    
    // 2. Từ time_t sang struct tm (giờ địa phương)
    tm* local_time = localtime(&now);
    cout << "Local time: " << asctime(local_time);
    
    // 3. Từ time_t sang struct tm (giờ UTC)
    tm* gmt_time = gmtime(&now);
    cout << "UTC time: " << asctime(gmt_time);
    
    // 4. Từ struct tm sang time_t
    time_t time_again = mktime(local_time);
    cout << "time_t value: " << time_again << " seconds since epoch" << endl;
    
    return 0;
}

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

int main() {
    time_t now = time(0);
    tm* ltm = localtime(&now);
    
    char buffer[80];
    
    // Định dạng: "Ngày DD/MM/YYYY HH:MM:SS"
    strftime(buffer, sizeof(buffer), "Ngày %d/%m/%Y %H:%M:%S", ltm);
    cout << buffer << endl;
    
    // Định dạng khác: "Thứ W, ngày D tháng M năm Y"
    setlocale(LC_ALL, "Vietnamese"); // Hỗ trợ tiếng Việt nếu có thể
    strftime(buffer, sizeof(buffer), "Ngày %A, %d tháng %m năm %Y", ltm);
    cout << buffer << endl;
    
    return 0;
}

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

int main() {
    // Lấy thời điểm hiện tại
    auto now = chrono::system_clock::now();
    
    // Chuyển đổi sang time_t để hiển thị dễ đọc
    time_t current_time = chrono::system_clock::to_time_t(now);
    
    // In thời gian hiện tại
    cout << "Current date time: " << ctime(&current_time);
    
    return 0;
}

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

int main() {
    vector<int> numbers(100000);
    
    // Khởi tạo vector với các số ngẫu nhiên
    for(int i = 0; i < numbers.size(); i++) {
        numbers[i] = rand();
    }
    
    // Đo thời gian sắp xếp
    auto start = chrono::high_resolution_clock::now();
    
    // Đoạn code cần đo thời gian
    sort(numbers.begin(), numbers.end());
    
    // Kết thúc đo thời gian
    auto end = chrono::high_resolution_clock::now();
    
    // Tính thời gian thực thi với các đơn vị khác nhau
    auto milliseconds = chrono::duration_cast<chrono::milliseconds>(end - start);
    auto microseconds = chrono::duration_cast<chrono::microseconds>(end - start);
    auto nanoseconds = chrono::duration_cast<chrono::nanoseconds>(end - start);
    
    cout << "Sorting time:" << endl;
    cout << milliseconds.count() << " mili seconds" << endl;
    cout << microseconds.count() << " micro seconds" << endl;
    cout << nanoseconds.count() << " nano seconds" << endl;
    
    return 0;
}

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

int main() {
    // Tạo các khoảng thời gian
    chrono::hours hrs(1);                  // 1 giờ
    chrono::minutes mins(60);              // 60 phút
    chrono::seconds secs(60*60);           // 3600 giây
    chrono::milliseconds ms(60*60*1000);   // 3,600,000 milli giây
    
    // So sánh các khoảng thời gian
    if (hrs == mins && mins == secs && secs == ms) {
        cout << "All are equal!" << endl;
    }
    
    // Tạo khoảng thời gian phức tạp
    auto complex_duration = hrs + chrono::minutes(30) + chrono::seconds(15);
    
    // Chuyển đổi sang milli giây
    auto ms_count = chrono::duration_cast<chrono::milliseconds>(complex_duration);
    cout << "1 hour, 30 mins, 15 seconds = " << ms_count.count() << " milli seconds" << endl;
    
    return 0;
}

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

int main() {
    // Lấy thời điểm hiện tại
    auto now = chrono::system_clock::now();
    
    // Thêm 1 ngày vào thời điểm hiện tại
    auto tomorrow = now + chrono::hours(24);
    
    // Thêm 1 tuần
    auto next_week = now + chrono::hours(24 * 7);
    
    // Chuyển đổi sang time_t để hiển thị
    time_t now_time = chrono::system_clock::to_time_t(now);
    time_t tomorrow_time = chrono::system_clock::to_time_t(tomorrow);
    time_t next_week_time = chrono::system_clock::to_time_t(next_week);
    
    cout << "Current time: " << ctime(&now_time);
    cout << "Tomorrow, same time: " << ctime(&tomorrow_time);
    cout << "Next week, same time: " << ctime(&next_week_time);
    
    // Tính khoảng thời gian giữa hai thời điểm
    auto duration = next_week - now;
    auto hours = chrono::duration_cast<chrono::hours>(duration);
    
    cout << "From now until next week: " << hours.count() << " hours" << endl;
    
    return 0;
}

#include <iostream>
#include <chrono>
#include <format> // Yêu cầu C++20
using namespace std;

int main() {
    // Lưu ý: Code này yêu cầu trình biên dịch hỗ trợ C++20
    auto now = chrono::system_clock::now();
    auto local_time = chrono::current_zone()->to_local(now);
    
    // Sử dụng std::format cho định dạng thời gian đẹp
    cout << format("Date: {:%d/%m/%Y}", local_time) << endl;
    cout << format("Time: {:%H:%M:%S}", local_time) << endl;
    cout << format("Full: {:%A, %d %B %Y at %H:%M:%S}", local_time) << endl;
    
    return 0;
}

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

int main() {
    time_t now = time(0);
    tm* ltm = localtime(&now);
    char buffer[80];
    
    // Bảng các định dạng phổ biến
    cout << "Common date formats:" << endl;
    
    // 1. DD/MM/YYYY
    strftime(buffer, 80, "%d/%m/%Y", ltm);
    cout << "1. " << buffer << endl;
    
    // 2. MM/DD/YYYY (US format)
    strftime(buffer, 80, "%m/%d/%Y", ltm);
    cout << "2. " << buffer << endl;
    
    // 3. YYYY-MM-DD (ISO format)
    strftime(buffer, 80, "%Y-%m-%d", ltm);
    cout << "3. " << buffer << endl;
    
    // 4. DD Month YYYY (Ex: 01 January 2023)
    strftime(buffer, 80, "%d %B %Y", ltm);
    cout << "4. " << buffer << endl;
    
    // 5. Weekday, Day Month Year
    strftime(buffer, 80, "%A, %d %B %Y", ltm);
    cout << "5. " << buffer << endl;
    
    cout << "\nCommon time formats:" << endl;
    
    // 1. HH:MM:SS
    strftime(buffer, 80, "%H:%M:%S", ltm);
    cout << "1. " << buffer << endl;
    
    // 2. HH:MM:SS AM/PM
    strftime(buffer, 80, "%I:%M:%S %p", ltm);
    cout << "2. " << buffer << endl;
    
    // 3. 24-hour time with timezone
    strftime(buffer, 80, "%H:%M:%S %Z", ltm);
    cout << "3. " << buffer << endl;
    
    return 0;
}

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

int main() {
    auto now = chrono::system_clock::now();
    auto today = chrono::year_month_day{chrono::floor<chrono::days>(now)};
    
    // Date formats
    cout << format("DD/MM/YYYY: {:%d/%m/%Y}", now) << endl;
    cout << format("YYYY-MM-DD: {:%Y-%m-%d}", now) << endl;
    cout << format("Full date: {:%A, %d %B %Y}", now) << endl;
    
    // Time formats  
    cout << format("Time: {:%H:%M:%S}", now) << endl;
    cout << format("Time with AM/PM: {:%I:%M:%S %p}", now) << endl;
    cout << format("Full date and time: {:%d/%m/%Y %H:%M:%S}", now) << endl;
    
    return 0;
}

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

// Hàm sắp xếp nổi bọt
void bubbleSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n-1; i++)
        for (int j = 0; j < n-i-1; j++)
            if (arr[j] > arr[j+1])
                swap(arr[j], arr[j+1]);
}

int main() {
    // Tạo mảng ngẫu nhiên
    const int SIZE = 10000;
    vector<int> arr1(SIZE), arr2(SIZE);
    
    for (int i = 0; i < SIZE; i++) {
        int num = rand() % 10000;
        arr1[i] = arr2[i] = num;
    }
    
    // Đo thời gian sắp xếp nổi bọt
    auto start1 = chrono::high_resolution_clock::now();
    bubbleSort(arr1);
    auto end1 = chrono::high_resolution_clock::now();
    auto duration1 = chrono::duration_cast<chrono::milliseconds>(end1 - start1);
    
    // Đo thời gian sắp xếp của thư viện chuẩn
    auto start2 = chrono::high_resolution_clock::now();
    sort(arr2.begin(), arr2.end());
    auto end2 = chrono::high_resolution_clock::now();
    auto duration2 = chrono::duration_cast<chrono::milliseconds>(end2 - start2);
    
    cout << "Bubble sort running time: " << duration1.count() << " ms" << endl;
    cout << "std::sort running time: " << duration2.count() << " ms" << endl;
    cout << "std::sort faster than " << (float)duration1.count() / duration2.count() << " times" << endl;
    
    return 0;
}

#include <iostream>
#include <chrono>
#include <thread>
#include <conio.h> // Cho getch() - Lưu ý: chỉ hoạt động trên Windows
using namespace std;

int main() {
    int minutes = 0, seconds = 0;
    
    cout << "Enter minutes: ";
    cin >> minutes;
    cout << "Enter seconds: ";
    cin >> seconds;
    
    int total_seconds = minutes * 60 + seconds;
    
    cout << "Countdown started! Press any key to stop.\n";
    
    for (int i = total_seconds; i >= 0; i--) {
        // Xóa màn hình theo cách đơn giản (không hiệu quả lắm)
        system("cls"); // Windows
        // system("clear"); // Linux/Mac
        
        int m = i / 60;
        int s = i % 60;
        
        cout << "Time remaining: ";
        cout << (m < 10 ? "0" : "") << m << ":";
        cout << (s < 10 ? "0" : "") << s << endl;
        
        // Kiểm tra nếu người dùng nhấn phím
        if (_kbhit()) {
            _getch(); // Đọc phím đã nhấn
            cout << "Timer stopped!" << endl;
            break;
        }
        
        // Đợi 1 giây
        this_thread::sleep_for(chrono::seconds(1));
    }

    cout << "Countdown finished!" << endl;
    return 0;
}

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

int main() {
    time_t now = time(0);
    
    // Giờ địa phương
    tm* local = localtime(&now);
    cout << "Local time: " << asctime(local);
    
    // Giờ UTC
    tm* utc = gmtime(&now);
    cout << "UTC time: " << asctime(utc);
    
    return 0;
}

time_t t1 = time(0);
// ... một số xử lý
time_t t2 = time(0);
double seconds = difftime(t2, t1);

auto start = chrono::high_resolution_clock::now();
// ... code cần đo
auto end = chrono::high_resolution_clock::now();
auto duration = chrono::duration_cast<chrono::microseconds>(end - start);
cout << duration.count() << " microseconds" << endl;