一句话总结

这是 musl libc 中将time_t（秒数）转换为struct tm（年月日时分秒）的核心函数，用纯整数运算 + 400年周期分解，在不查表、不循环的情况下完成转换，是时间处理领域教科书级的实现。

先看最终效果

输入：t = 1719072000（即 2024-06-22 16:00:00 UTC，武汉是 UTC+8，所以是 2024-06-23 00:00:00）

输出tm结构体：

核心设计思想：为什么这么写？

1. 选了一个"神仙基准点"：LEAPOCH

#define LEAPOCH (946684800LL + 86400*(31+29)) // = 2000-03-01 00:00:00 UTC

为什么选2000年3月1日？

一句话：选这个点，是为了让后续所有计算都变成"正向累加"，消除边界条件。

2. 400年周期分解：把大问题拆成小问题

格里高利历的闰年规则：

能被4整除 → 闰年 能被100整除 → 不是闰年 能被400整除 → 又是闰年

对应的天数：

代码的分解过程：

总天数 days ↓ qc_cycles = days / 146097 → 过去了多少个400年 remdays = days % 146097 → 400年内剩余天数 ↓ c_cycles = remdays / 36524 → 过去了多少个100年 ↓ (如果c_cycles==4，减1，因为第4个100年不是闰年) remdays -= c_cycles × 36524 ↓ q_cycles = remdays / 1461 → 过去了多少个4年 ↓ (如果q_cycles==25，减1，因为第25个4年不是闰年) remdays -= q_cycles × 1461 ↓ remyears = remdays / 365 → 过去了多少个整年 ↓ (如果remyears==4，减1，因为第4年是闰年) remdays -= remyears × 365 ↓ 此时 remdays 就是当年的第几天（从0开始）

这套分解的精髓：每一层都用if (x == N) x--处理"闰年例外"，把复杂的闰年规则压缩成了常数次判断。

3. 最反直觉的设计：从3月开始算一年

这是整个函数最难理解的地方：

static const char days_in_month[] = {31,30,31,30,31,31,30,31,30,31,31,29}; // ↑3月 ↑ ↑2月(闰年29天)

数组从3月开始排，2月被放在最后。

为什么？

因为闰日在2月29日。

如果从1月开始：

• 平年：1月31, 2月28, 3月31...
• 闰年：1月31, 2月29, 3月31...

2月的天数不一样，导致从1月到12月的天数在闰年/平年不一致，月份计算逻辑要分情况。

从3月开始：

• 3月→2月，这12个月的天数在闰年/平年完全一样（因为闰日已经被"包含"在这段里了）
• 闰年的影响只在最后通过leap标志统一处理

// 找到月份 for (months=0; days_in_month[months] <= remdays; months++) remdays -= days_in_month[months]; // months=0 → 3月, months=9 → 12月, months=10 → 1月(需要年份+1) if (months >= 10) { months -= 12; years++; } // 最终填入 tm tm->tm_mon = months + 2; // 0→1月, 1→2月, ..., 9→10月, 10→11月, 11→0月? 不对 // 等一下，months=0(3月) → tm_mon=2(3月) ✓ // months=9(12月) → tm_mon=11(12月) ✓ // months=10(1月) → tm_mon=12?? 不对，前面 months-=12 了

让我重新理一下：

months 循环结束后的值： 0 → 经过了3月 1 → 经过了3月+4月 ... 9 → 经过了3月~12月 10 → 经过了3月~1月（下一年） if (months >= 10) { months -= 12; // 10→-2, 11→-1 years++; } 所以： months=0 → tm_mon=0+2=2 (3月) ✓ months=9 → tm_mon=9+2=11 (12月) ✓ months=10 → months=-2 → tm_mon=-2+2=0 (1月) ✓ months=11 → months=-1 → tm_mon=-1+2=1 (2月) ✓

完美自洽。

4. 闰年判断：一行代码搞定

leap = !remyears && (q_cycles || !c_cycles);

翻译成人话：

组合起来就是：能被4整除，且（不被100整除 或 被400整除）→ 标准闰年规则。

5. 星期几的计算：为什么是(3+days)%7？

wday = (3+days)%7; // 0=周日, 1=周一, ..., 6=周六

LEAPOCH 是 2000-03-01，星期三。

• days=0→(3+0)%7=3→ 周三 ✓
• days=1→(3+1)%7=4→ 周四 ✓

如果days是负数（2000-03-01 之前的时间）：

if (wday < 0) wday += 7;

保证结果在[0, 6]。

完整流程图

time_t t │ ▼ t - LEAPOCH = secs（相对秒数） │ ├─→ secs / 86400 = days（天数） ├─→ secs % 86400 = remsecs（当天秒数） │ ▼ days 分解： ├─→ qc_cycles = days / 146097（400年周期数） ├─→ remdays = days % 146097 ├─→ c_cycles = remdays / 36524（100年周期，修正第4个） ├─→ q_cycles = remdays / 1461（4年周期，修正第25个） ├─→ remyears = remdays / 365（整年，修正第4个） └─→ remdays = 当年第几天（从0开始） │ ▼ leap = !remyears && (q_cycles || !c_cycles) yday = remdays + 31 + 28 + leap（调整到0-based） │ ▼ months 循环（从3月开始减） │ ├─→ months >= 10 → months-=12, years++ │ ▼ years = remyears + 4*q_cycles + 100*c_cycles + 400*qc_cycles │ ▼ 填充 struct tm tm_year = years + 100 tm_mon = months + 2 tm_mday = remdays + 1 tm_wday = (3+days)%7 tm_yday = yday tm_hour/min/sec 从 remsecs 分解

边界检查：为什么有两处返回 -1？

// 第一处：防止年份溢出 int if (t < INT_MIN * 31622400LL || t > INT_MAX * 31622400LL) return -1; // 第二处：防止 tm_year 溢出 if (years+100 > INT_MAX || years+100 < INT_MIN) return -1;

31622400 ≈ 365.2425 × 86400，约等于一年的秒数。

tm_year是从1900开始的偏移，所以years + 100就是实际年份。

这两处检查保证了：输入的时间戳对应的年份必须在int范围内（约 ±29亿年，足够覆盖任何实际场景）。

对比其他实现

musl 的实现在嵌入式和高性能场景下优势明显：没有数据依赖，CPU 流水线友好，不怕缓存未命中。

关键 takeaway

这段代码不长，但每一行都有明确的数学含义。读懂它，你就理解了公历时间系统的本质。

参考：musl libc src/time/__secs_to_tm.c