如何在std::chrono::seconds与nanoseconds间实现无损转换？

核心问题分析 #

你用std::chrono::duration_cast<std::chrono::seconds>转换时，会截断纳秒部分的低9位数据（也就是小于1秒的部分），这是duration_cast的设计特性——只保留目标周期的整数倍部分，反向转换必然丢失信息。要实现无损转换，自定义类型需要完整存储原始纳秒的全部64位数据，同时支持以秒为单位的访问。

方案1：基于完整纳秒存储的自定义秒类型 #

直接在自定义类型内部存储原始的int64_t纳秒值，对外提供秒相关的访问接口，转换回nanoseconds时直接返回原始值，完全无损。

代码实现示例 #

#include <chrono>
#include <cassert>

struct long_data_seconds {
private:
    std::int64_t total_nanoseconds_;

public:
    // 从nanoseconds构造，完整保存数据
    explicit long_data_seconds(std::chrono::nanoseconds ns)
        : total_nanoseconds_(ns.count()) {}

    // 转换回nanoseconds，无信息丢失
    operator std::chrono::nanoseconds() const {
        return std::chrono::nanoseconds(total_nanoseconds_);
    }

    // 获取整数秒部分（等价于原来的duration_cast结果）
    std::int64_t count_seconds() const {
        return total_nanoseconds_ / 1'000'000'000;
    }

    // 获取剩余的纳秒部分（0~999,999,999）
    std::int32_t remaining_nanoseconds() const {
        return static_cast<std::int32_t>(total_nanoseconds_ % 1'000'000'000);
    }

    // 可选：以浮点秒形式返回（适合显示，注意浮点数精度限制）
    double as_double() const {
        return static_cast<double>(total_nanoseconds_) / 1'000'000'000.0;
    }
};

// 使用示例
int main() {
    std::chrono::nanoseconds t1(1705218518267805576);
    long_data_seconds t2(t1);
    std::chrono::nanoseconds t3(t2);
    // 断言会成功
    assert(t1 == t3);
}

方案2：利用std::chrono的高精度duration（依赖编译器支持） #

如果你的编译器支持__int128（比如GCC、Clang），可以直接定义一个以秒为周期、用128位整数存储的duration类型，这样能精确容纳所有64位纳秒值（1e9 * 2^63 ≈ 9e18，远小于__int128的取值范围）：

#include <chrono>
#include <cassert>

using long_data_seconds = std::chrono::duration<__int128, std::ratio<1>>;

// 使用示例
int main() {
    std::chrono::nanoseconds t1(1705218518267805576);
    // 无需duration_cast，可精确转换
    long_data_seconds t2 = t1;
    std::chrono::nanoseconds t3 = t2;
    assert(t1 == t3);
}

这个方案贴合std::chrono的设计，但缺点是依赖编译器对128位整数的支持，且__int128无法直接用标准IO函数输出，需要额外处理。

方案3：拆分存储秒和纳秒余数 #

如果不想存储完整纳秒值，可以拆分存储整数秒和剩余纳秒（0~999,999,999），转换时组合回去：

#include <chrono>
#include <cassert>

struct long_data_seconds {
    std::int64_t seconds;
    std::int32_t nanoseconds; // 范围0~999,999,999

    explicit long_data_seconds(std::chrono::nanoseconds ns) {
        auto cnt = ns.count();
        seconds = cnt / 1'000'000'000;
        nanoseconds = static_cast<std::int32_t>(cnt % 1'000'000'000);
        // 处理负时间的边界情况
        if (nanoseconds < 0) {
            seconds -= 1;
            nanoseconds += 1'000'000'000;
        }
    }

    operator std::chrono::nanoseconds() const {
        return std::chrono::nanoseconds(seconds * 1'000'000'000LL + nanoseconds);
    }
};

// 使用示例
int main() {
    std::chrono::nanoseconds t1(1705218518267805576);
    long_data_seconds t2(t1);
    std::chrono::nanoseconds t3(t2);
    assert(t1 == t3);
}

这个方案的好处是可以直接访问秒和纳秒部分，适合需要分别处理这两个值的场景，同时避免了大整数的使用。

内容的提问来源于stack exchange，提问作者linuxbeginner