C++时间和随机数相关库¶

#include <iostream>
#include <ratio>

int main() 
{
    // 定义ratio类型
    using one_third = std::ratio<1, 3>;
    using two_fourths = std::ratio<2, 4>; // 会被约简为1/2

    // 访问num和den
    std::cout << "one_third: " << one_third::num << "/" << one_third::den << std::endl;
    std::cout << "two_fourths: " << two_fourths::num << "/" << two_fourths::den << std::endl;

    // Ratio算术
    using sum = std::ratio_add<one_third, two_fourths>; // 1/3 + 1/2 = 5/6
    std::cout << "Sum: " << sum::num << "/" << sum::den << std::endl;

    using product = std::ratio_multiply<one_third, std::kilo>; // (1/3) * (1000/1) = 1000/3
    std::cout << "Product: " << product::num << "/" << product::den << std::endl;

    // Ratio比较
    // 比较1/3和1/2
    bool less = std::ratio_less<one_third, two_fourths>::value;
    std::cout << "Is 1/3 less than 1/2? " << std::boolalpha << less << std::endl; // 输出rue

    return 0;
}

#include <iostream>
#include <chrono>
#include <ctime> // for std::time_t, std::gmtime, std::put_time
#include <iomanip> // for std::put_time
#include <thread> // for std::this_thread::sleep_for

int main() 
{
    // --- system_clock ---
    std::chrono::system_clock::time_point sys_now = std::chrono::system_clock::now();
    std::time_t sys_now_c = std::chrono::system_clock::to_time_t(sys_now);
    // 将 time_t 转换为 UTC 时间结构
    std::tm sys_now_tm = *std::gmtime(&sys_now_c);
    std::cout << "System clock time: " << std::put_time(&sys_now_tm, "%Y-%m-%d %H:%M:%S UTC") << std::endl;

    // --- steady_clock ---
    std::chrono::steady_clock::time_point steady_start = std::chrono::steady_clock::now();
    std::cout << "Starting steady clock measurement..." << std::endl;
    // 模拟一些工作
    // 线程睡眠
    std::this_thread::sleep_for(std::chrono::milliseconds(150));
    std::chrono::steady_clock::time_point steady_end = std::chrono::steady_clock::now();
    // 计算时间差 (duration)
    std::chrono::duration<double, std::milli> elapsed_ms = steady_end - steady_start;
    std::cout << "Elapsed time (steady_clock): " << elapsed_ms.count() << " ms" << std::endl;

    // --- high_resolution_clock ---
    std::chrono::high_resolution_clock::time_point high_res_now = std::chrono::high_resolution_clock::now();
    // high_resolution_clock通常没有直接转换为time_t的方法，因为它可能是 steady_clock
    // 但我们可以获取自纪元以来的时间
    auto high_res_epoch = high_res_now.time_since_epoch();
    // 将其转换为纳秒
    long long ns = std::chrono::duration_cast<std::chrono::nanoseconds>(high_res_epoch).count();
    std::cout << "High resolution clock (nanoseconds since epoch): " << ns << std::endl;
    std::cout << "High resolution clock is steady: " << std::boolalpha << std::chrono::high_resolution_clock::is_steady << std::endl;


    return 0;
}

#include <iostream>
#include <chrono>

int main() 
{
    // 创建 durations
    std::chrono::seconds s(5);                     // 5 秒
    std::chrono::milliseconds ms = std::chrono::milliseconds(1500); // 1500 毫秒
    std::chrono::duration<double, std::ratio<1, 3>> third_of_sec(1.0); // 1/3 秒

    // 访问count()
    std::cout << "Seconds count: " << s.count() << std::endl;
    std::cout << "Milliseconds count: " << ms.count() << std::endl;
    std::cout << "Third of second count: " << third_of_sec.count() << std::endl;

    // Duration 算术
    auto total_ms = s + ms; // 5s + 1500ms = 6500ms
    // 注意：结果类型是两个操作数周期的最大公约数，表示类型是std::common_type
    // 在这里，结果类型可能是milliseconds或更精细的类型
    // 为了明确，我们通常使用duration_cast
    std::chrono::milliseconds total_ms_casted = std::chrono::duration_cast<std::chrono::milliseconds>(s) + ms;
    std::cout << "Total milliseconds: " << total_ms_casted.count() << std::endl;

    auto half_s = s / 2; // 结果是2秒 (整数除法)
    std::cout << "Half of 5 seconds (integer division): " << half_s.count() << std::endl;

    std::chrono::duration<double> s_double = s; // 隐式转换为double类型的秒
    auto precise_half_s = s_double / 2.0; // 结果是2.5秒
    std::cout << "Half of 5 seconds (double division): " << precise_half_s.count() << std::endl;

    // Duration比较
    if (ms < s) {
        std::cout << "1500 ms is less than 5 s" << std::endl;
    }

    // duration_cast
    std::chrono::seconds ms_to_s = std::chrono::duration_cast<std::chrono::seconds>(ms); // 1500ms -> 1s (截断)
    std::cout << "1500 ms casted to seconds: " << ms_to_s.count() << std::endl;

    std::chrono::microseconds s_to_us = std::chrono::duration_cast<std::chrono::microseconds>(s); // 5s -> 5,000,000 us
    std::cout << "5 s casted to microseconds: " << s_to_us.count() << std::endl;

    // C++14 字面量 (需要 using namespace std::chrono_literals)
    using namespace std::chrono_literals;
    auto literal_duration = 1h + 30min + 5s + 100ms + 20us + 300ns;
    std::cout << "Literal duration in nanoseconds: "
              << std::chrono::duration_cast<std::chrono::nanoseconds>(literal_duration).count() << std::endl;


    return 0;
}

#include <iostream>
#include <chrono>
#include <thread> // for sleep_for

int main() {
    using namespace std::chrono; // 方便使用 chrono 下的类型

    // 获取当前时间点
    system_clock::time_point tp_sys_now = system_clock::now();
    steady_clock::time_point tp_steady_now = steady_clock::now();

    // 获取自纪元以来的时间
    auto sys_epoch_duration = tp_sys_now.time_since_epoch();
    auto steady_epoch_duration = tp_steady_now.time_since_epoch();

    // 转换为特定单位
    long long sys_ms_count = duration_cast<milliseconds>(sys_epoch_duration).count();
    long long steady_ns_count = duration_cast<nanoseconds>(steady_epoch_duration).count();

    std::cout << "System clock time_point (ms since epoch): " << sys_ms_count << std::endl;
    std::cout << "Steady clock time_point (ns since epoch): " << steady_ns_count << std::endl;

    // Time point 算术
    system_clock::time_point tp_sys_later = tp_sys_now + minutes(10); // 10 分钟后的时间点
    auto diff_duration = tp_sys_later - tp_sys_now; // 计算差值，结果是 duration
    std::cout << "Difference is: " << duration_cast<seconds>(diff_duration).count() << " seconds" << std::endl;

    // Time point 比较
    steady_clock::time_point tp_steady_start = steady_clock::now();
    std::this_thread::sleep_for(50ms); // 暂停 50 毫秒
    steady_clock::time_point tp_steady_end = steady_clock::now();

    if (tp_steady_end > tp_steady_start) {
        std::cout << "Steady clock time point increased." << std::endl;
    }

    // time_point_cast
    // 将 system_clock 的 time_point 精度改为秒
    time_point<system_clock, seconds> tp_sys_seconds = time_point_cast<seconds>(tp_sys_now);
    // 再次获取自纪元以来的时间 (以秒为单位)
    std::cout << "System clock time_point (seconds since epoch): "
              << tp_sys_seconds.time_since_epoch().count() << std::endl;


    return 0;
}

using namespace std::chrono_literals;
auto my_duration = 2h + 45min + 10s;
std::cout << "Duration in seconds: " << my_duration.count() << std::endl; // 输出 9910

#include <iostream>
#include <random>
#include <vector>
#include <numeric> // for std::iota
#include <algorithm> // for std::shuffle

int main() {
    // --- 使用 random_device 获取种子 ---
    std::random_device rd; // 获取一个随机设备
    unsigned int seed = rd(); // 用它生成一个种子
    std::cout << "Seed generated by random_device: " << seed << std::endl;
    std::cout << "random_device entropy: " << rd.entropy() << std::endl;

    // --- 创建和使用引擎 ---
    // 使用 random_device 的种子初始化梅森旋转引擎
    std::mt19937 engine(seed);

    std::cout << "Generating 5 numbers using mt19937:" << std::endl;
    for (int i = 0; i < 5; ++i) {
        // 调用 operator() 生成原始随机整数
        std::cout << engine() << " ";
    }
    std::cout << std::endl;

    // 引擎的范围
    std::cout << "mt19937 min: " << engine.min() << std::endl;
    std::cout << "mt19937 max: " << engine.max() << std::endl;

    // discard
    engine.discard(10); // 跳过 10 个数
    std::cout << "Next number after discarding 10: " << engine() << std::endl;

    // 重新 seeding
    engine.seed(12345); // 使用固定种子
    std::cout << "First number after seeding with 12345: " << engine() << std::endl;
    engine.seed(12345); // 再次使用相同种子
    std::cout << "First number after seeding with 12345 again: " << engine() << std::endl; // 输出应与上一个相同


    return 0;
}

#include <iostream>
#include <random>
#include <vector>
#include <map>
#include <iomanip> // for std::fixed, std::setprecision

int main() {
    // --- 设置引擎 ---
    std::random_device rd;
    std::mt19937 gen(rd()); // 使用 random_device 播种

    // --- 均匀分布 ---
    std::uniform_int_distribution<> distrib_int(1, 6); // [1, 6] 整数
    std::uniform_real_distribution<> distrib_real(0.0, 1.0); // [0.0, 1.0) 浮点数

    std::cout << "Rolling a die 5 times: ";
    for (int i = 0; i < 5; ++i) {
        std::cout << distrib_int(gen) << " "; // 使用引擎生成符合分布的数
    }
    std::cout << std::endl;

    std::cout << "Generating 5 random doubles [0.0, 1.0): ";
    std::cout << std::fixed << std::setprecision(4); // 设置输出格式
    for (int i = 0; i < 5; ++i) {
        std::cout << distrib_real(gen) << " ";
    }
    std::cout << std::endl;

    // --- 正态分布 ---
    double mean = 5.0;
    double stddev = 2.0;
    std::normal_distribution<> distrib_normal(mean, stddev);

    std::cout << "Generating 10 numbers from normal distribution (mean=5.0, stddev=2.0):" << std::endl;
    std::map<int, int> hist; // 用于统计直方图
    for (int i = 0; i < 10000; ++i) {
        double num = distrib_normal(gen);
        ++hist[std::round(num)]; // 四舍五入并计数
    }
    // 简单打印直方图
    for(auto const& [val, count] : hist) {
        // 限制输出范围，避免过多输出
        if (val >= 0 && val <= 10) {
             std::cout << std::setw(2) << val << ": " << std::string(count / 100, '*') << '\n';
        }
    }


    // --- 离散分布 ---
    std::vector<double> weights = {10.0, 20.0, 70.0}; // 权重对应索引 0, 1, 2
    // 索引 0 的概率是 10/(10+20+70) = 10%
    // 索引 1 的概率是 20/(10+20+70) = 20%
    // 索引 2 的概率是 70/(10+20+70) = 70%
    std::discrete_distribution<> distrib_discrete(weights.begin(), weights.end());

    std::cout << "Generating 10 numbers from discrete distribution (weights 10, 20, 70): ";
    std::map<int, int> discrete_counts;
    for (int i = 0; i < 1000; ++i) {
        discrete_counts[distrib_discrete(gen)]++;
    }
     for(auto const& [val, count] : discrete_counts) {
        std::cout << "Index " << val << ": " << count << " times ";
    }
    std::cout << std::endl;

    // 访问分布参数
    auto params = distrib_normal.param();
    std::cout << "Normal distribution mean: " << params.mean() << ", stddev: " << params.stddev() << std::endl;


    return 0;
}

#include <iostream>
#include <random>
#include <vector>
#include <numeric>   // for std::iota
#include <algorithm> // for std::shuffle, std::copy
#include <iterator>  // for std::ostream_iterator
#include <array>     // for std::array

int main() {
    // --- seed_seq ---
    std::seed_seq sseq{1, 2, 3, 4, 5}; // 从整数列表创建 seed_seq
    std::array<std::uint32_t, 8> seeds; // 准备接收生成的种子
    sseq.generate(seeds.begin(), seeds.end()); // 生成种子序列

    std::cout << "Generated seeds using seed_seq: ";
    for (std::uint32_t seed : seeds) {
        std::cout << seed << " ";
    }
    std::cout << std::endl;

    // 使用 seed_seq 初始化引擎
    std::mt19937 engine_from_sseq(sseq);
    std::cout << "First number from engine seeded by seed_seq: " << engine_from_sseq() << std::endl;

    // --- generate_canonical ---
    std::random_device rd_canon;
    std::mt19937 gen_canon(rd_canon());
    std::cout << "Generating 5 canonical doubles [0, 1): ";
    std::cout << std::fixed << std::setprecision(10);
    for (int i = 0; i < 5; ++i) {
        // 生成具有 64 位随机性的 double
        double canonical_rand = std::generate_canonical<double, 64>(gen_canon);
        std::cout << canonical_rand << " ";
    }
    std::cout << std::endl;

    // --- shuffle ---
    std::vector<int> v(10);
    std::iota(v.begin(), v.end(), 1); // 用 1, 2, ..., 10 填充向量

    std::cout << "Original vector: ";
    std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;

    std::random_device rd_shuffle;
    std::mt19937 g_shuffle(rd_shuffle());

    std::shuffle(v.begin(), v.end(), g_shuffle); // 使用引擎打乱向量

    std::cout << "Shuffled vector: ";
    std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;


    return 0;
}