template<class Rep,class Period = std::ratio<1>> 
class duration;

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<chrono>
#include <ratio>//提供編譯期有理數(shù)算術(shù)的支持。
using namespace std::chrono;
//duration 的基本操作
void TestDuration()
{
    // 1. 構(gòu)造與觀察
    milliseconds ms(1024);           // 1024毫秒
    std::cout << ms.count() << " ms\n"; // 輸出: 1024 ms
    // 2. 算術(shù)運(yùn)算
    seconds s = duration_cast<seconds>(milliseconds(2500) + milliseconds(500));
    std::cout << s.count() << " s\n"; // 輸出 3 s
    // 3. 比較運(yùn)算
    if (minutes(1) > seconds(30)) 
    {
        std::cout << "1分鐘比30秒長\n";
    }
    // 4. 單位轉(zhuǎn)換
    seconds s2 = duration_cast<seconds>(milliseconds(1500)); // 顯式轉(zhuǎn)換: 1s
    std::cout << s2.count() << " s (截?cái)嗪?\n"; // 輸出: 1 s
    duration<double, std::ratio<60>> d_min = seconds(90); // 隱式轉(zhuǎn)換: 1.5分鐘
    std::cout << d_min.count() << " 分鐘\n"; // 輸出: 1.5 分鐘
    // 5. 特殊值
    std::cout << "duration<int>::zero(): " << duration<int>::zero().count() << "\n";
}

//C++11定義
template< class Rep >
struct treat_as_floating_point : std::is_floating_point<Rep> {};

//C++17定義
template< class Rep >
constexpr bool treat_as_floating_point_v = treat_as_floating_point<Rep>::value;

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<chrono>
#include <ratio>//提供編譯期有理數(shù)算術(shù)的支持。
using namespace std::chrono;
//treat_as_floating_point 
void TestTAFP()
{
    // 檢查特征值
    std::cout << std::boolalpha;
    std::cout << "treat_as_floating_point<int>: "
        << treat_as_floating_point<int>::value << "\n";   // false
    std::cout << "treat_as_floating_point<double>: "
        << treat_as_floating_point<double>::value << "\n"; // true
    // 演示其對(duì)轉(zhuǎn)換的影響
    seconds s(1); // 1秒
    // 1. 目標(biāo)為 double (treat_as_floating_point == true) -> 隱式轉(zhuǎn)換 OK
    duration<double, std::milli> d1 = s; // 自動(dòng)變?yōu)?1000.0 毫秒
    std::cout << "d1 (double毫秒): " << d1.count() << " ms\n";
    // 2. 目標(biāo)為 int (treat_as_floating_point == false) -> 隱式轉(zhuǎn)換 ERROR
    // duration<int, milli> d2 = s; // 編譯錯(cuò)誤: 存在截?cái)囡L(fēng)險(xiǎn)
    // 3. 必須顯式轉(zhuǎn)換
    duration<int, std::milli> d2 = duration_cast<milliseconds>(s);
    std::cout << "d2 (int毫秒, 顯式轉(zhuǎn)換): " << d2.count() << " ms\n";
}

template<class Rep>
struct duration_values;

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<chrono>
#include <ratio>//提供編譯期有理數(shù)算術(shù)的支持。
using namespace std::chrono;
void TestDurationV()
{
    // 1. 獲取基本類型的邊界值
    std::cout << "duration_values<int>::zero(): "
        << duration_values<int>::zero() << "\n";
    std::cout << "duration_values<int>::min(): "
        << duration_values<int>::min() << "\n";
    std::cout << "duration_values<int>::max(): "
        << duration_values<int>::max() << "\n";

    std::cout << "duration_values<double>::zero(): "
        << duration_values<double>::zero() << "\n";
    std::cout << "duration_values<double>::min(): "
        << duration_values<double>::min() << "\n";
    std::cout << "duration_values<double>::max(): "
        << duration_values<double>::max() << "\n";

    // 2. 它們與 duration 的成員函數(shù)返回的時(shí)長對(duì)象的關(guān)系
    // 以下兩者本質(zhì)上是等價(jià)的
    auto zero_dur1 = duration<int>::zero(); // 返回 duration<int> 對(duì)象
    auto zero_dur2 = duration<int>(duration_values<int>::zero()); // 顯式構(gòu)造

    std::cout << "duration<int>::zero().count(): "
        << zero_dur1.count() << "\n";
    std::cout << "手動(dòng)構(gòu)造的零時(shí)長 count(): "
        << zero_dur2.count() << "\n";
}

template<class Clock, class Duration = typename Clock::duration>
class time_point;

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <chrono>
#include <thread>

using namespace std::chrono;

void TestTimePoint()
{
    // 1. 獲取當(dāng)前時(shí)間點(diǎn)（基于 system_clock）
    system_clock::time_point now = system_clock::now();
    std::cout << "當(dāng)前時(shí)間點(diǎn)已獲取\n";

    // 2. 獲取從紀(jì)元到現(xiàn)在的時(shí)長
    auto since_epoch = now.time_since_epoch();
    std::cout << "從紀(jì)元至今已過去 "
        << duration_cast<seconds>(since_epoch).count() << " 秒\n";

    // 3. 時(shí)間點(diǎn)算術(shù)：計(jì)算 1 小時(shí)后的時(shí)間點(diǎn)
    system_clock::time_point one_hour_later = now + hours(1);
    std::cout << "1 小時(shí)后的時(shí)間點(diǎn)已計(jì)算\n";

    // 4. 時(shí)間點(diǎn)減法：計(jì)算兩個(gè)時(shí)間點(diǎn)的間隔
    auto diff = one_hour_later - now;
    std::cout << "時(shí)間間隔為 " << duration_cast<minutes>(diff).count() << " 分鐘\n";

    // 5. 時(shí)間點(diǎn)比較
    if (one_hour_later > now) 
    {
        std::cout << "1小時(shí)后確實(shí)晚于現(xiàn)在\n";
    }

    // 6. 單位轉(zhuǎn)換示例
    auto now_ms = time_point_cast<milliseconds>(now);
    std::cout << "當(dāng)前時(shí)間點(diǎn)的毫秒精度計(jì)數(shù): "
        << now_ms.time_since_epoch().count() << " ms\n";

    // 7. 休眠示例（演示時(shí)間點(diǎn)與實(shí)際等待）
    auto start = steady_clock::now();
    std::this_thread::sleep_for(milliseconds(100));
    auto end = steady_clock::now();
    std::cout << "休眠了 "
        << duration_cast<microseconds>(end - start).count()
        << " 微秒\n";

}

template<class Dest, class Source> 
struct clock_time_conversion;

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <chrono>
#include <thread>

using namespace std::chrono;

void TestCTC()
{
    // 獲取當(dāng)前系統(tǒng)時(shí)間點(diǎn)（UTC 時(shí)間）
    auto sys_now = system_clock::now();

    // 1. 使用 clock_cast 將系統(tǒng)時(shí)間轉(zhuǎn)換為 UTC 時(shí)鐘的時(shí)間點(diǎn)
    utc_clock::time_point utc_now = clock_cast<utc_clock>(sys_now);
    std::cout << "系統(tǒng)時(shí)間已轉(zhuǎn)換為 UTC 時(shí)間\n";

    // 2. 使用 clock_time_conversion 直接進(jìn)行轉(zhuǎn)換（等價(jià)于 clock_cast）
    clock_time_conversion<utc_clock, system_clock> converter;
    utc_clock::time_point utc_now2 = converter(sys_now);
    std::cout << "使用轉(zhuǎn)換器再次轉(zhuǎn)換成功\n";

    // 3. 轉(zhuǎn)換回系統(tǒng)時(shí)間
    auto sys_now2 = clock_cast<system_clock>(utc_now);
    if (sys_now == sys_now2) 
    {
        std::cout << "往返轉(zhuǎn)換后時(shí)間點(diǎn)一致\n";
    }

    // 4. 與 TAI 時(shí)間互轉(zhuǎn)（展示不同時(shí)鐘系統(tǒng)）
    tai_clock::time_point tai_now = clock_cast<tai_clock>(sys_now);
    std::cout << "系統(tǒng)時(shí)間已轉(zhuǎn)換為 TAI 時(shí)間\n";

    // 計(jì)算當(dāng)前 UTC 和 TAI 的偏移（通常為 37 秒，因跳秒而變）
    auto offset = tai_now - clock_cast<tai_clock>(utc_now);
    std::cout << "當(dāng)前 UTC 與 TAI 偏移: "
        << duration_cast<seconds>(offset).count() << " 秒\n";
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <chrono>
#include <thread>
using namespace std::chrono;
//C++11的基礎(chǔ)時(shí)鐘
void TestClocks11()
{
    // 1. system_clock: 獲取當(dāng)前時(shí)間點(diǎn)并轉(zhuǎn)換為可讀形式
    auto sys_now = system_clock::now();
    std::time_t sys_now_c = system_clock::to_time_t(sys_now);
    std::cout << "system_clock 當(dāng)前時(shí)間: " << std::ctime(&sys_now_c);
    // 2. steady_clock: 測量代碼塊執(zhí)行時(shí)間
    auto start = steady_clock::now();
    std::this_thread::sleep_for(milliseconds(100)); // 模擬工作
    auto end = steady_clock::now();
    auto elapsed = duration_cast<microseconds>(end - start);
    std::cout << "steady_clock 測量耗時(shí): " << elapsed.count() << " us\n";
    // 3. high_resolution_clock: 最高精度計(jì)時(shí)（用法與 steady_clock 類似）
    auto hr_start = high_resolution_clock::now();
    // ... 一些工作 ...
    auto hr_end = high_resolution_clock::now();
    auto hr_elapsed = duration_cast<nanoseconds>(hr_end - hr_start);
    std::cout << "high_resolution_clock 耗時(shí): " << hr_elapsed.count() << " ns\n";
    // 4. 檢查時(shí)鐘的穩(wěn)定性
    std::cout << std::boolalpha;
    std::cout << "system_clock 是否穩(wěn)定: " << system_clock::is_steady << "\n";
    std::cout << "steady_clock 是否穩(wěn)定: " << steady_clock::is_steady << "\n";
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <chrono>
#include <thread>
using namespace std::chrono;
//C++20的時(shí)鐘
void TestClocks20()
{
    // 1. 獲取當(dāng)前 UTC 時(shí)間
    auto utc_now = utc_clock::now();
    std::cout << "UTC 時(shí)間已獲取\n";

    // 2. 獲取當(dāng)前 TAI 時(shí)間
    auto tai_now = tai_clock::now();
    std::cout << "TAI 時(shí)間已獲取\n";

    // 3. 時(shí)鐘轉(zhuǎn)換 (C++20 的 clock_cast)
    auto sys_from_utc = clock_cast<system_clock>(utc_now);
    auto sys_from_tai = clock_cast<system_clock>(tai_now);

    std::cout << "UTC 和 TAI 時(shí)間已轉(zhuǎn)換為 system_clock\n";

    // 4. file_clock 的使用
    auto file_now = file_clock::now();
    auto sys_from_file = clock_cast<system_clock>(file_now); // 或 clock_cast<system_clock>
    std::cout << "文件時(shí)間已轉(zhuǎn)換為系統(tǒng)時(shí)間\n";

    // 5. 注意：local_t 不能直接調(diào)用 now()
    // auto local_now = local_t::now(); // 編譯錯(cuò)誤
    // 它通常與 zoned_time 配合使用
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <chrono>
#include <thread>
using namespace std::chrono;
//C++20輔助模板——檢測是否為時(shí)鐘類型
class MYclass
{};
void TestCheck()
{
    std::cout << std::boolalpha;
    std::cout << "is_clock_v<system_clock>: "
        << std::chrono::is_clock_v<std::chrono::system_clock> << "\n"; // true
    std::cout << "is_clock_v<MYclass>: "
        << std::chrono::is_clock_v<MYclass> << "\n"; // false
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <chrono>
using namespace std::chrono;
using namespace std::literals; // 用于 "y" 和 "d" 字面量
int main() 
{
    // 1. 創(chuàng)建日期的多種方式
    auto ymd1 = 2024y / May / 21d;          // 最直觀
    auto ymd2 = 21d / May / 2024;           // 順序可調(diào)
    auto ymd3 = year_month_day{ 2024y, May, 21d }; // 顯式構(gòu)造

    std::cout << "ymd1 = " << ymd1 << "\n"; // 輸出: 2024-05-21
    std::cout << "ymd2 = " << ymd2 << "\n";
    std::cout << "ymd3 = " << ymd3 << "\n";

    // 2. 訪問日期字段
    std::cout << "年份: " << ymd1.year() << "\n";
    std::cout << "月份: " << ymd1.month() << "\n";
    std::cout << "日: " << ymd1.day() << "\n";

    // 3. 日期算術(shù)
    auto ymd_next_month = ymd1 + months(1);
    std::cout << "下個(gè)月: " << ymd_next_month << "\n"; // 2024-06-21

    auto ymd_next_year = ymd1 + years(1);
    std::cout << "明年: " << ymd_next_year << "\n";     // 2025-05-21

    //將 year_month_day 顯式轉(zhuǎn)換為 sys_days，進(jìn)行天數(shù)算術(shù)，再隱式轉(zhuǎn)換回來 
    auto ymd_next_week = year_month_day{ sys_days{ymd1} + days(7) };
    std::cout << "一周后: " << ymd_next_week << "\n";   // 2024-05-28

    // 4. 處理特殊日期：某月最后一天
    auto last_day_of_feb_2024 = 2024y / February / last;
    std::cout << "2024年2月最后一天: " << last_day_of_feb_2024 << "\n"; // 2024-02-29 (閏年)
    std::cout << "那天是星期幾? " << weekday{ last_day_of_feb_2024 } << "\n"; // 轉(zhuǎn)換為 weekday

    // 5. 處理復(fù)雜規(guī)則：某月的第N個(gè)星期W
    auto third_wed_may_2024 = 2024y / May / Wednesday[3];
    std::cout << "2024年5月第三個(gè)星期三: " << third_wed_may_2024 << "\n";

    // 6. 檢查日期有效性
    year_month_day invalid_date = 2024y / February / 30d;
    std::cout << "2024-02-30 有效嗎? " << std::boolalpha << invalid_date.ok() << "\n"; // false

    // 7. 轉(zhuǎn)換為 time_point (用于與 system_clock 交互)
    sys_days tp = sys_days{ ymd1 }; // 轉(zhuǎn)換為基于 days 的時(shí)間點(diǎn)
    std::cout << "時(shí)間點(diǎn) (自紀(jì)元天數(shù)): " << tp.time_since_epoch().count() << " 天\n";

    // 8. 兩個(gè)日期相減得到天數(shù)間隔
    auto xmas = 2024y / December / 25d;
    auto days_until_xmas = sys_days{ xmas } - sys_days{ ymd1 };
    std::cout << "距離2024年圣誕節(jié)還有: " << days_until_xmas.count() << " 天\n";

    // 9. 使用 weekday 計(jì)算下一個(gè)周五
    weekday today = weekday{ ymd1 }; // 2024-05-21 是星期二
    weekday fri = Friday;
    auto days_until_fri = (fri - today).count(); // weekday 差值
    if (days_until_fri <= 0) days_until_fri += 7;
    std::cout << "下一個(gè)周五在 " << days_until_fri << " 天后\n";

    return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <chrono>
#include <iostream>
#include <string>
#include< cassert >
class Date {
private:
    std::chrono::year_month_day ymd_;

public:
    // 1. 構(gòu)造函數(shù)
    // 從 std::chrono::year_month_day 構(gòu)造（隱式轉(zhuǎn)換允許）
    Date(const std::chrono::year_month_day& ymd) : ymd_(ymd) {
        if (!ymd_.ok()) {
            throw std::invalid_argument("Invalid date");
        }
    }

    // 從年、月、日整數(shù)構(gòu)造
    Date(int year, int month, int day)
        : Date(std::chrono::year{ year } / month / day) {
    }

    // 2. 靜態(tài)工廠：獲取當(dāng)前日期
    static Date today() {
        auto now = std::chrono::system_clock::now();
        auto today_days = std::chrono::floor<std::chrono::days>(now);
        return Date{ std::chrono::year_month_day{today_days} };
    }

    // 3. 訪問器
    int year() const { return static_cast<int>(ymd_.year()); }
    unsigned month() const { return static_cast<unsigned>(ymd_.month()); }
    unsigned day() const { return static_cast<unsigned>(ymd_.day()); }

    // 獲取星期幾 (Sunday = 0, Monday = 1, ..., Saturday = 6)
    unsigned weekday() const {
        std::chrono::weekday wd{ std::chrono::sys_days{ymd_} };
        return wd.c_encoding(); // 返回 0-6
    }

    // 判斷是否為閏年
    bool isLeapYear() const { return ymd_.year().is_leap(); }

    // 4. 日期算術(shù)運(yùn)算符
    // 加天數(shù)
    Date operator+(const std::chrono::days& d) const {
        auto sd = std::chrono::sys_days{ ymd_ } + d;
        return Date{ std::chrono::year_month_day{sd} };
    }

    // 減天數(shù)
    Date operator-(const std::chrono::days& d) const {
        return *this + (-d);
    }

    // 加月份
    Date operator+(const std::chrono::months& m) const {
        auto new_ymd = ymd_ + m;
        // 處理可能的無效日期（如 1月31日 + 1個(gè)月 = 2月31日，會(huì)調(diào)整到2月最后一天）
        if (!new_ymd.ok()) {
            new_ymd = new_ymd.year() / new_ymd.month() / std::chrono::last;
        }
        return Date{ new_ymd };
    }

    // 減月份
    Date operator-(const std::chrono::months& m) const {
        return *this + (-m);
    }

    // 加年份
    Date operator+(const std::chrono::years& y) const {
        auto new_ymd = ymd_ + y;
        // 處理閏年2月29日的情況
        if (!new_ymd.ok()) {
            new_ymd = new_ymd.year() / new_ymd.month() / std::chrono::last;
        }
        return Date{ new_ymd };
    }

    // 減年份
    Date operator-(const std::chrono::years& y) const {
        return *this + (-y);
    }

    // 復(fù)合賦值運(yùn)算符（可選）
    Date& operator+=(const std::chrono::days& d) { return *this = *this + d; }
    Date& operator-=(const std::chrono::days& d) { return *this = *this - d; }
    Date& operator+=(const std::chrono::months& m) { return *this = *this + m; }
    Date& operator-=(const std::chrono::months& m) { return *this = *this - m; }
    Date& operator+=(const std::chrono::years& y) { return *this = *this + y; }
    Date& operator-=(const std::chrono::years& y) { return *this = *this - y; }

    // 5. 比較運(yùn)算符（C++20 可以自動(dòng)生成，但為清晰顯式聲明）
    auto operator<=>(const Date&) const = default; // C++20 三路比較，自動(dòng)生成所有關(guān)系運(yùn)算符

    // 6. 差值計(jì)算
    // 返回兩個(gè)日期相差的天數(shù)（忽略時(shí)間部分）
    std::chrono::days daysUntil(const Date& other) const {
        return std::chrono::sys_days{ other.ymd_ } - std::chrono::sys_days{ ymd_ };
    }

    // 返回兩個(gè)日期相差的完整月份數(shù)（近似，基于日歷月）
    // 注意：這不是一個(gè)精確的物理時(shí)間差，而是日歷上的月份差。
    int monthsUntil(const Date& other) const {
        // 簡化實(shí)現(xiàn)：將年份差 * 12 + 月份差，再根據(jù)日進(jìn)行調(diào)整
        int y1 = year(), m1 = month(), d1 = day();
        int y2 = other.year(), m2 = other.month(), d2 = other.day();

        int month_diff = (y2 - y1) * 12 + (m2 - m1);
        // 如果結(jié)束日期的日號(hào)小于開始日期的日號(hào)，則不滿整月
        if (d2 < d1) {
            --month_diff;
        }
        return month_diff;
    }

    // 7. 友元輸出運(yùn)算符
    friend std::ostream& operator<<(std::ostream& os, const Date& date) {
        os << date.year() << '-'
            << (date.month() < 10 ? "0" : "") << date.month() << '-'
            << (date.day() < 10 ? "0" : "") << date.day();
        return os;
    }

    // 獲取內(nèi)部 year_month_day 的引用（用于需要直接操作底層類型的場景）
    const std::chrono::year_month_day& get_ymd() const { return ymd_; }
};

#define _CRT_SECURE_NO_WARNINGS
#include"Date.h"
using namespace std::chrono_literals; // 用于 h, min, s, ms, us, ns, y
void testDate() 
{
    std::cout << "=== 開始測試 Date 類 ===\n";
    // 1. 構(gòu)造函數(shù)與 today()
    std::cout << "1. 構(gòu)造函數(shù)測試:\n";
    Date d1(2024, 5, 21);
    std::cout << "   d1: " << d1 << "\n";
    assert(d1.year() == 2024 && d1.month() == 5 && d1.day() == 21);
    auto d_today = Date::today();
    std::cout << "   Today: " << d_today << "\n";
    // 2. 無效日期拋出異常
    std::cout << "2. 無效日期測試 (2024-02-30): ";
    try {
        Date invalid(2024, 2, 30);
        std::cout << "FAILED: 未拋出異常\n";
    }
    catch (const std::invalid_argument& e) {
        std::cout << "PASSED: 捕獲異常 - " << e.what() << "\n";
    }
    catch (...) {
        std::cout << "FAILED: 捕獲到未知異常\n";
    }
    // 3. 閏年判斷
    std::cout << "3. 閏年判斷測試:\n";
    assert(Date(2024, 1, 1).isLeapYear() == true);
    assert(Date(2023, 1, 1).isLeapYear() == false);
    assert(Date(2000, 1, 1).isLeapYear() == true);
    assert(Date(1900, 1, 1).isLeapYear() == false);
    std::cout << "   所有閏年判斷通過\n";
    // 4. 星期幾
    std::cout << "4. 星期幾測試:\n";
    // 2024-05-21 是星期二 (ISO: 2, C: 2? 需要查證，我們的weekday返回c_encoding)
    // 根據(jù)常識(shí)，2024-05-21 是星期二，在weekday中周二對(duì)應(yīng)1（如果周日是0，周一是1，周二是2）
    // 但c_encoding() 周日=0，周一=1，周二=2，周三=3，周四=4，周五=5，周六=6
    assert(Date(2024, 5, 21).weekday() == 2); // 星期二
    assert(Date(2024, 5, 22).weekday() == 3); // 星期三
    assert(Date(2024, 5, 19).weekday() == 0); // 星期日
    std::cout << "   所有星期幾判斷通過\n";
    // 5. 日期算術(shù)
    std::cout << "5. 日期算術(shù)測試:\n";
    Date d2(2024, 5, 21);
    auto d_plus_7 = d2 + std::chrono::days(7);
    std::cout << "   " << d2 << " + 7 days = " << d_plus_7 << "\n";
    assert(d_plus_7 == Date(2024, 5, 28));
    auto d_plus_1m = d2 + std::chrono::months(1);
    std::cout << "   " << d2 << " + 1 month = " << d_plus_1m << "\n";
    assert(d_plus_1m == Date(2024, 6, 21));
    auto d_plus_1y = d2 + std::chrono::years(1);
    std::cout << "   " << d2 << " + 1 year = " << d_plus_1y << "\n";
    assert(d_plus_1y == Date(2025, 5, 21));
    // 邊界測試：月末
    Date d3(2024, 1, 31);
    auto d_plus_1m_jan = d3 + std::chrono::months(1);
    std::cout << "   " << d3 << " + 1 month = " << d_plus_1m_jan << "\n";
    assert(d_plus_1m_jan == Date(2024, 2, 29)); // 2024是閏年，所以是2月29日
    Date d4(2023, 1, 31);
    auto d_plus_1m_jan_nonleap = d4 + std::chrono::months(1);
    std::cout << "   " << d4 << " + 1 month = " << d_plus_1m_jan_nonleap << "\n";
    assert(d_plus_1m_jan_nonleap == Date(2023, 2, 28)); // 2023非閏年，2月28日
    // 跨年測試
    Date d5(2024, 12, 15);
    auto d_plus_2m = d5 + std::chrono::months(2);
    std::cout << "   " << d5 << " + 2 months = " << d_plus_2m << "\n";
    assert(d_plus_2m == Date(2025, 2, 15));
    // 6. 比較運(yùn)算符
    std::cout << "6. 比較運(yùn)算符測試:\n";
    Date d6a(2024, 5, 21);
    Date d6b(2024, 5, 22);
    Date d6c(2024, 5, 21);
    assert(d6a == d6c);
    assert(d6a != d6b);
    assert(d6a < d6b);
    assert(d6a <= d6c);
    assert(d6b > d6a);
    assert(d6b >= d6c);
    std::cout << "   所有比較運(yùn)算符通過\n";
    // 7. 差值計(jì)算
    std::cout << "7. 差值計(jì)算測試:\n";
    Date d7_start(2024, 5, 21);
    Date d7_end(2024, 12, 25);
    auto days_diff = d7_start.daysUntil(d7_end);
    std::cout << "   " << d7_start << " 到 " << d7_end << " 相差 "
        << days_diff.count() << " 天\n";
    assert(days_diff.count() == 218); // 手工驗(yàn)證 5月剩余10天 + 6月30 + 7月31 + 8月31 + 9月30 + 10月31 + 11月30 + 12月25 = 218
    auto months_diff = d7_start.monthsUntil(d7_end);
    std::cout << "   " << d7_start << " 到 " << d7_end << " 相差 "
        << months_diff << " 個(gè)整月\n";
    assert(months_diff == 7); // 5月21日到12月21日是7個(gè)月，到12月25日超過21日，所以仍是7個(gè)整月
    // 跨年差值
    Date d7_start2(2024, 12, 25);
    Date d7_end2(2025, 1, 10);
    auto days_diff2 = d7_start2.daysUntil(d7_end2);
    std::cout << "   " << d7_start2 << " 到 " << d7_end2 << " 相差 "
        << days_diff2.count() << " 天\n";
    assert(days_diff2.count() == 16); // 12月剩余7天 + 1月10天 = 16
    // 8. 復(fù)合賦值
    std::cout << "8. 復(fù)合賦值測試:\n";
    Date d8(2024, 5, 21);
    d8 += std::chrono::days(10);
    std::cout << "   +=10天: " << d8 << "\n";
    assert(d8 == Date(2024, 5, 31));
    d8 += std::chrono::months(1);
    std::cout << "   +=1月: " << d8 << "\n";
    assert(d8 == Date(2024, 6, 30)); // 5月31日+1月 -> 6月30日
    d8 -= std::chrono::years(1);
    std::cout << "   -=1年: " << d8 << "\n";
    assert(d8 == Date(2023, 6, 30));
    std::cout << "=== 所有測試通過 ===\n";
}
int main() 
{
    testDate();
    return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#pragma once 
#include <vector>
#include <cassert>
#include <iostream>
using std::vector;
using std::cout;
using std::endl;
namespace MyMemoryPool
{
    // 內(nèi)存對(duì)齊：向上取整到指定對(duì)齊值（align 必須是 2 的冪）
    constexpr inline size_t align_up(size_t n, size_t align)
    {
        return (n + (align - 1)) & ~(align - 1);
    }
    // 固定大小內(nèi)存池，每個(gè)塊大小相同，按頁管理
    class FixedSizePool
    {
    public:
        // 構(gòu)造函數(shù)：指定塊大小和每頁塊數(shù)（默認(rèn)1024）
        explicit FixedSizePool(size_t blockSize, size_t blockPerPage = 1024)
            : block_Size(adjust_block_size(blockSize)),   // 確保塊至少能存一個(gè)指針并正確對(duì)齊
            block_Per_Page(blockPerPage),
            free_list(nullptr),
            total_allocations(0),
            total_deallocations(0),
            page_count(0)
        {
        }
        // 析構(gòu)函數(shù)：釋放所有已分配的頁
        ~FixedSizePool()
        {
            for (void* page : Pages)
            {
                ::operator delete[](page);   // 全局釋放，避免調(diào)用析構(gòu)函數(shù)
            }
        }
        // 分配一個(gè)塊
        void* allocate()
        {
            if (!free_list)                  // 空閑鏈表為空，需要擴(kuò)充新頁
            {
                expand();
            }
            Node* head = free_list;
            free_list = head->next;
            ++total_allocations;
            return head;
        }
        // 回收一個(gè)塊
        void deallocate(void* p)
        {
            if (!p) return;
            Node* node = static_cast<Node*>(p);
            node->next = free_list;
            free_list = node;
            ++total_deallocations;
        }
        // 獲取塊大小
        size_t Get_block_Size() const { return block_Size; }
        size_t Get_block_Per_Page() const { return block_Per_Page; }
        // 打印統(tǒng)計(jì)信息
        void print_stats() const
        {
            std::cout << "內(nèi)存池統(tǒng)計(jì):" << std::endl;
            std::cout << "  總分配次數(shù): " << total_allocations << std::endl;
            std::cout << "  總釋放次數(shù): " << total_deallocations << std::endl;
            std::cout << "  當(dāng)前使用中: " << (total_allocations - total_deallocations) << std::endl;
            std::cout << "  頁數(shù)量: " << page_count << std::endl;
            std::cout << "  內(nèi)存使用量: " << (page_count * block_Size * block_Per_Page) << " 字節(jié)" << std::endl;
        }
    private:
        // 結(jié)點(diǎn)結(jié)構(gòu)，用于空閑鏈表
        struct Node
        {
            Node* next;
        };
        // 申請(qǐng)新的一頁內(nèi)存，并將其切分為多個(gè)塊鏈入空閑鏈表
        void expand()
        {
            size_t page_bytes = block_Size * block_Per_Page;
            char* page = static_cast<char*>(::operator new[](page_bytes));
            Pages.push_back(page);
            ++page_count;
            // 將當(dāng)前頁的所有塊串聯(lián)成鏈表
            for (size_t i = 0; i < block_Per_Page; ++i)
            {
                char* block = page + i * block_Size;
                Node* n = reinterpret_cast<Node*>(block);
                n->next = free_list;
                free_list = n;
            }
        }
        // 調(diào)整塊大?。捍_保至少 sizeof(void*) 并正確對(duì)齊
        size_t adjust_block_size(size_t s) const
        {
            size_t min_size = sizeof(void*);
            return align_up(s < min_size ? min_size : s, alignof(void*));
        }
        Node* free_list;               // 空閑鏈表頭
        size_t block_Size;              // 實(shí)際塊大小（已調(diào)整）
        size_t block_Per_Page;           // 每頁塊數(shù)
        vector<void*> Pages;             // 記錄所有分配過的頁，用于析構(gòu)時(shí)釋放
        // 統(tǒng)計(jì)變量
        size_t total_allocations;
        size_t total_deallocations;
        size_t page_count;
    };
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <chrono>
#include <vector>
#include "MemoryPool.h"
using namespace MyMemoryPool;
using namespace std::chrono;
// 通用測試模板：執(zhí)行 iterations 次分配和釋放，返回耗時(shí)（秒）
template <typename AllocFunc, typename DeallocFunc>
double run_test(size_t iterations, AllocFunc alloc, DeallocFunc dealloc) {
    std::vector<void*> pointers;
    pointers.reserve(iterations);
    auto start = high_resolution_clock::now();
    for (size_t i = 0; i < iterations; ++i) {
        pointers.emplace_back(alloc());
    }
    for (void* p : pointers) {
        dealloc(p);
    }
    auto end = high_resolution_clock::now();
    duration<double> elapsed = end - start;
    return elapsed.count();
}
int main() {
    const size_t BLOCK_SIZE = 256;          // 每個(gè)塊 256 字節(jié)
    const size_t BLOCKS_PER_PAGE = 1024;   // 每頁 1024 塊
    const size_t ITERATIONS = 1000000;      // 分配/釋放 100 萬次
    std::cout << "===== 性能對(duì)比測試 =====\n";
    std::cout << "塊大小: " << BLOCK_SIZE << " 字節(jié)\n";
    std::cout << "每頁塊數(shù): " << BLOCKS_PER_PAGE << "\n";
    std::cout << "分配/釋放次數(shù): " << ITERATIONS << "\n\n";
    // 1. 內(nèi)存池測試
    {
        FixedSizePool pool(BLOCK_SIZE, BLOCKS_PER_PAGE);
        double pool_time = run_test(ITERATIONS,
            [&pool]() { return pool.allocate(); },
            [&pool](void* p) { pool.deallocate(p); }
        );
        std::cout << "內(nèi)存池耗時(shí): " << pool_time << " 秒\n";
        pool.print_stats();
    }
    std::cout << "\n";
    // 2. 直接 new/delete 測試
    {
        double new_time = run_test(ITERATIONS,
            []() { return ::operator new(BLOCK_SIZE); },
            [](void* p) { ::operator delete(p); }
        );
        std::cout << "new/delete 耗時(shí): " << new_time << " 秒\n";
    }
    return 0;
}