C++：数组、字符串、指针和引用、时间戳、覆盖静态存储区问题
数组：
从这开始不记录琐碎东西了加快速度
setw() 函数控制输出宽带
最下面几个涉及指针的先搁置
字符串
char site[2] = {'a'};同于char str[2]={'a','\0'}，编译器会自动添加字符串结束符\0。
字符数组长度最少是2，因为结束符'\0'要占用一位
strlen可以输出C语言的不包括最后\0的长度，char site[2] = {'a'};输出1
这些东西刷算法题目的时候就会，但算法题需要的是思维和代码能力，而上面这些都是琐碎的知识点，不会就查没啥难度。
我的观点：
没点基础还真看不懂菜鸟教程，我是有基础，刷过算法，有C语言语法知识，想通过自己的节奏来学习，用菜鸟教程作为一个引导，知道该学什么，上面出现的知识就去追问AIGPT理清楚，这基于的是我的学习能力，而单纯的说菜鸟教程讲的东西真的是一坨屎。很多地方有错误，或者说引起歧义的地方，懂的就懂了，不懂的真看不懂
指针
写法int*和int *均可
关于存储区：
存储区分为静态、堆、栈
变量用static修饰，就叫静态变量，静态变量和全局变量一样，都存储在静态存储区，程序结束时自动销毁或者说释放
不用static的话就叫局部变量，存储在栈空间，函数结束自动销毁或者说释放
通过malloc函数是在堆空间上分配，动态分配内存，需要手动free释放，否则会导致这些内存无法被程序或操作系统回收，长时间积累会导致程序占用过多内存，影响性能甚至崩溃。
malloc可以动态分配内存空间，有着灵活的生命周期管理，避免空间浪费。
学(回顾)了指针开始回顾之前数组那章节里搁置的几个东西
上文提过随机数不可以没NULL参数（C编译器可能允许），srand((unsigned)time(NULL));是生成随机种子，即初始值，然后来通过rand，即计算机自带的生成器函数，来生成随机数
rand上文说最大是32767但根据不同编译器和系统，可能超过32767，
关于指针细节：
在 C++ 中，指针进行加 1 操作时，会根据其指向的数据类型的大小来移动相应的字节数。对于 int* 类型的指针 p，加 1 会使指针向后移动 sizeof(int) 个字节，刚好指向下一个 int 元素，从而可以访问数组中的下一个元素。
关于随机数细节：
srand 以一个时间点为参数播种，当执行的随机数在极短的时间内，时间是没有变化的，比如10微秒的时间里实际就是度过了10微秒，但计算机要求产生80个时间种子，所以必定会存在同一个微秒内产生8个时间种子。所以 srand 函数要放在 rand 循环的外面避免每次循环产生的随机数一样。
# include<stdlib.h>
# include<iostream>
# include<time.h>
int main(){
// srand((unsigned)time(NULL));
for (int i = 0; i < 100000; ++i) {
srand((unsigned)time(NULL));
int a=rand();
std::cout<<a<<std::endl;
}
}
继续看下一个C++ 指向数组的指针
继续看C++ 传递数组给函数
以上是数组那章节下面的关于指针的扩展，现在回来继续看指针章节下面的扩展
其中 C++ 指针 vs 数组 挺有用的
#include <iostream>
using namespace std;
const int MAX = 3;
int main ()
{
int var[MAX] = {10, 100, 200};
for (int i = 0; i < MAX; i++)
{
*var = i; // 这是正确的语法
var++; // 这是不正确的
}
}
哎，算法自己思考有思路是一大关需要长时间锻炼，写出来能AC又是一大关
而C++这些乱七八糟的不存在这么多说道，感觉看懂就是王道。还是感觉刷题有趣。
好饿~~~~(>_<)~~~~，每天4点睡，吃不饱饭
再看这一章节C++ 传递指针给函数 ，没啥说的，但放这是觉得这章可以更好理解上面*var = i这句话，
代码（我就不明白了为啥他妈的总加那么多没用的空行和输出注释呢？真他么der！看着真别扭，）
#include <iostream>
#include <ctime>
using namespace std;
void getSeconds(unsigned long *par);
int main ()
{
unsigned long sec=4;
cout<<sec<<endl;
getSeconds( &sec );
cout<<sec<<endl;
}
void getSeconds(unsigned long *par)
{
*par = time( NULL );
return;
}其实教程里翻来覆去说的感觉好多种类，都只要明白后，就会发现都是重复的，代码看懂就行
收获：千万别抠字眼，菜鸟教程里好多狗屁不通的语句，越研究越离谱，直接去追问AIGPT，懂这个知识点就行。
不像定义，他是绝对精准正确的，多读可以理解含义，“书读百遍其义自见”，但读定义其实很der，很劝退。这个之前学算法就深有感触
C++引用 ，说的挺好的
解释：
- 当你将一个指针作为函数参数传递时，你实际上是传递了变量的地址。在函数内部，你可以通过解引用指针来访问和修改该地址上存储的值。
- 在
modifyValue函数中，ptr是一个指向int类型的指针，通过*ptr对指针进行解引用，我们可以修改指针所指向的内存位置的值。 - 在
main函数中，调用modifyValue(&value);，将value的地址传递给modifyValue函数，因此modifyValue函数可以修改value的值。
- 当你将一个引用作为函数参数传递时，你实际上是将变量本身传递给函数，而不是变量的副本。引用是变量的别名，对引用的操作等同于对原变量的操作。
- 在
modifyValue函数中，ref是int类型的引用，对ref的任何修改都会直接影响到传递给函数的原始变量。 - 在
main函数中，调用modifyValue(value);，将value作为引用传递给modifyValue函数，因此modifyValue函数可以修改value的值。
引用下面的 C++ 把引用作为返回值
当函数返回一个引用时，则返回一个指向返回值的隐式指针。这样，函数就可以放在赋值语句的左边
里面的代码值得多看
C++ 日期 & 时间 —— 给我整吐了
td::tm 只是个结构体类型，定义变量时系统不会自动填充时间数据。要获取当前系统时间并赋值给它，得用 std::time 和 std::localtime 等函数进行初始化。
获取时间戳的代码：
#include <iostream>
#include <ctime>
int main() {
std::time_t t;
// 调用 std::time 函数，将结果存储到 t 中
std::time(&t);
std::cout << "Seconds since January 1, 1970: " << t << std::endl;
// 也可以直接使用返回值
std::time_t another_t = std::time(nullptr);
std::cout << "Same result: " << another_t << std::endl;
}代码解释：
关于time()内的值，
std::time函数可以接受一个std::time_t*类型的指针作为参数，即std::time(&t)中的&t就是取变量t的地址。当传入指针时，函数会把获取到的时间值存储到该指针所指向的内存位置；如果传入nullptr，函数依然会返回当前时间，但不会存储到任何变量中。
时间戳以 UTC 为基准，UTC 并非北京当地时间。北京处于东八区，也就是 UTC+8 时区。这意味着北京当地时间比 UTC 时间快 8 个小时。比如，当 UTC 时间是中午 12 点时，北京时间则是晚上 20 点。
为什么叫时间戳：
时间戳（Timestamp之所以被称为 “时间戳”，是因为它就像一个时间的 “印章” 或 “标记”，具有以下特点和原因：）
本地local时间即北京时间，获取以后需要转化为本地时间
#include <iostream>
#include <ctime>
using namespace std;
int main() {
// 获取基于 UTC 的时间戳，即从 UNIX 纪元到现在 UTC 时间的秒数
std::time_t utcTimestamp = std::time(nullptr);
std::cout<< utcTimestamp << std::endl;
// 计算从 UNIX 纪元到现在北京时间（UTC+8）的秒数
const int beijingTimeZoneOffset = 8 * 60 * 60;
std::time_t beijingTimestamp = utcTimestamp + beijingTimeZoneOffset;
std::cout << beijingTimestamp << std::endl;
cout<<utcTimestamp-beijingTimestamp<<endl;
}用现成的函数就是：
#include <iostream>
#include <ctime>
using namespace std;
int main ()
{
// 获取当前时间
time_t now = time(NULL);
// 将时间转换为本地时间结构体
tm* localTime = localtime(&now);
if (localTime != nullptr) {
// 输出年，tm_year 从 1900 开始计数，所以要加 1900
cout << localTime->tm_year + 1900 << "-";
// 输出月，tm_mon 范围是 0 - 11，所以要加 1
cout << (localTime->tm_mon + 1) << "-";
// 输出日
cout << localTime->tm_mday << " ";
// 输出时
cout << localTime->tm_hour << ":";
// 输出分
cout << localTime->tm_min << ":";
// 输出秒
cout << localTime->tm_sec << endl;
}
}我真的好烦C++的这些各种库，方便是方便，但没刷题考验思维，满片子琐碎的不认识的函数、库、变量名，真的好心累好痛苦~~~~(>_<)~~
时间戳这查了好多都没写上来，脑子都要炸了，找不到解释对的
到这想到了几个问题
1、 -> 和 .
2、怎么证明时间戳是UTC，且比本地时间（北京）差8h
AI大模型解答：
关于1、
豆包：
关于2、
先科普拓展：
UTC（协调世界时）：是一种以原子时秒长为基础，在时刻上尽量接近于世界时的一种时间计量系统，它是全球通用的标准时间，为世界各地提供了一个统一的时间参考基准，常用于航空、航海、天文观测、国际通信等领域，以确保不同地区的时间同步和准确协调。一般各个国家都是UTC+-几
夏令时：
是一种为节约能源而人为规定地方时间的制度，在夏季将时间调快 1 小时。实行夏令时的目的主要是充分利用夏季白昼较长的特点，让人们早睡早起，减少照明等能源消耗。
但由于时间混乱、文化水平低认知不足难以适应、幅员辽阔，所以在1992年取消了，取消之前如果公司规定夏令时 8 点上班，则要北京时间 7 点上班。但需要注意的是，在夏令时期间，大家都统一使用拨快后的时间来安排工作和生活，所以在感知上就是按照 8 点来上班。
北京时间：
北京在赤道以北，北京中心位置的经纬度大致为北纬 39°56′、东经 116°20′2。整个北京市境处于东经 115°25′至 117°30′、北纬 39°26′至 41°03′之间
因为北京是首都所以叫北京时间，而北京时间为啥选择为UTC+8 ，因为国际上把时间，分为 东12西12共计24 个时区，而东八区涵盖了中国人口密集、经济活动最为活跃的大部分地区，能够更好地服务于全国的生产生活和社会管理，所以中国选择东八区的区时作为标准时间，即北京时间，
东八区是东经 120° 的地方时间。
科普完继续回来说，先说两个函数
std::localtime 是 C++ 标准库中的一个函数，用于将 time_t 类型的时间戳（通常是从 1970 年 1 月 1 日午夜开始的秒数）转换为本地时间，并将其存储在一个 tm 结构体中。这个过程涉及以下几个步骤：
- 接收 UTC 时间戳：std::localtime 接收一个指向 time_t 变量的指针。
- 应用时区偏移：根据系统配置的应用程序所在的时区，将 UTC 时间转换为本地时间。
- 填充 tm 结构体：将转换后的时间信息填入 tm 结构体中。
看代码（time里是NULL或者nullptr都行）
#include <iostream>
#include <ctime>
using namespace std;
int main ()
{
// 获取当前时间
time_t now = time(0);
// 将时间转换为本地时间结构体
tm* localTm = localtime(&now);
if (localTm != nullptr) {
// 输出星期几
cout << "星期几（0 代表周日）: " << localTm->tm_wday << endl;
// 使用 std::gmtime 将时间转换为 UTC 时间结构体
tm* utcTm = gmtime(&now);
// 使用 std::mktime 将本地时间结构体再转换回时间戳
time_t localTimeStamp = mktime(localTm);
// 使用 std::mktime 将 UTC 时间结构体再转换回时间戳
time_t utcTimeStamp = mktime(utcTm);
// 计算本地时间与 UTC 时间的差值（以秒为单位）
int timezoneOffset = localTimeStamp - utcTimeStamp;
cout << "本地时间与 UTC 时间的差值（秒）: " << timezoneOffset << endl;
}
}先说下在代码里添加 if (localTime != nullptr) { 这一条件判断语句，主要是为了保证程序的健壮性和安全性，下面来详细分析其作用：
好了解释完后发现，这段代码差值为0，疑惑来了，time函数获得的时间戳和本地时间即北京时间一样？
我把now转换去掉依旧是差异为0
#include <iostream>
#include <ctime>
using namespace std;
int main ()
{
// 获取当前时间
time_t now = time(0);
// 将时间转换为本地时间结构体
tm* localTm = localtime(&now);
if (localTm != nullptr) {
// 输出星期几
cout << "星期几（0 代表周日）: " << localTm->tm_wday << endl;
// 使用 std::gmtime 将时间转换为 UTC 时间结构体
// tm* utcTm = gmtime(&now);
// 使用 std::mktime 将本地时间结构体再转换回时间戳
time_t localTimeStamp = mktime(localTm);
// 使用 std::mktime 将 UTC 时间结构体再转换回时间戳
// time_t utcTimeStamp = mktime(utcTm);
// 计算本地时间与 UTC 时间的差值（以秒为单位）
int timezoneOffset = localTimeStamp - now;
cout << "本地时间与 UTC 时间的差值（秒）: " << timezoneOffset << endl;
}
}
救命的知乎直答：→ 百度文心技术大牛 → Deepseek：
先说几个基础知识：
①、difftime返回秒数差值
②、
std::tm utcTm(*utcTmConst);里的std::tm我知道，那(*utcTmConst);是啥意思，简单说下：
⑤、关于想验证本地时间转化函数 和 UTC时间转化函数，是否确实是差8小时，这里出了很大的问题，逐一思考这些破函数的意义
豆包和知乎直答都不行，豆包最差，知乎直答指出了问题但像个智障一样，完全解释不透彻，最后百度文心技术大牛GPT解释了（文心也不行了）
Q：（这段QA可以忽略）
我有相当大的疑惑，
1、mktime是tm结构体转化时间戳类型，那如果tm结构体不是本地时间呢？
2、有UTC结构体吗？
3、如果有UTC结构体，是不是会先算偏移量转成本地时间，然后再转时间戳？
4、还有gmtime是时间戳转化UTC结构体，如果传入的是本地时间，会转化成UTC时间再转成UTC结构体？A：（这段QA可以忽略）
但我还是有很多深入思考的问题不理解，没有任何AI大模型能解答我的问题，唉~~~~(>_<)~~~~
#include <iostream>
#include <ctime>
int main() {
std::time_t now = std::time(nullptr);
std::cout << std::localtime(&now)->tm_hour << std::endl;
std::cout << std::gmtime(&now)->tm_hour << std::endl;
}实践出真知，这些傻逼玩意真tm耽误事，怒了！！！实践得：
1、mktime只是转化为秒数，即时间戳，无关乎你传入的是本地还是UTC，它不做任何转化，只是计算传入时间数据的秒数
腾讯那玩意直接没考虑过
过于专业的东西豆包回答太垃圾，只能回答日常肤浅问题
知乎直答太不智能专业解答类似3s男，追问很不智能
百度文心作为我一直的靠山王牌也没扛住，解释的依旧有问题
试了下通义千问，通义千问骂他还给我扯一大堆，最后解释的有偏差，基本比豆包、知乎直答、文心牛，但依旧是没说清楚，最后还引入了手动调整 tm_isdst 字段：？？？，但之后彻底理解后发现他说的其实是对的，只是无法解释清楚，依旧Pass。但反应相当快，不需要思考一样
最后试了下deepseek，简直无敌，有点像降龙十八掌，但手总tm抽筋（第二个问题就崩溃了，呼吁那些傻逼别滥用这玩意了），但相当牛逼，名不虚传。之前我一直以为
这玩意有病吧 群众跟傻逼一样 他牛逼爆火在于性能那是真正开发者技术者开发这个大模型去开心的事，对于普通人还拿他当爹一样傻逼， deepseek解释的很烂，用之前的豆包不好吗 之前问了一个问题，全方位的差，比起豆包来说，况且豆包还是个三流货色，没知乎直答和百度技术大牛 所以群众就是90%都是傻逼 真想用这个搜索回答，方便生活工作。不应该是在这之前就用上其他大模型吗，热搜有了才用，一群傻逼 deepseek优势跟普通人没关系啊那是性能，跟开发大模型的团体有关系，作为普通人难道不是用豆包，知乎直答，文心更好吗 https://m.weibo.cn/status/Pbyzuh6CQ
#include <iostream>
#include <ctime>
#include<iomanip>
using namespace std;
int main() {
// 获取当前的UTC时间戳
std::time_t utcTimestamp = std::time(nullptr);
cout<<"std::time：\n"<<utcTimestamp<<"\n"<<endl;
// 将UTC时间戳转换为本地时间的tm结构体
tm* Tm = std::gmtime(&utcTimestamp);
time_t Time = std::mktime(Tm);
cout<<"std::time时间戳后，gmtime再mktime：Time\n"<<Time<<"\n"<<endl;
cout << "具体为："
<< (Tm->tm_year + 1900) << "-" // 年份从1900年开始计数，所以需要加上1900
<< std::setw(2) << std::setfill('0') << (Tm->tm_mon + 1) << "-" // 月份从0开始计数，所以需要加上1，并使用setw和setfill来格式化输出
<< std::setw(2) << std::setfill('0') << Tm->tm_mday << " "
<< std::setw(2) << std::setfill('0') << Tm->tm_hour << ":"
<< std::setw(2) << std::setfill('0') << Tm->tm_min << ":"
<< std::setw(2) << std::setfill('0') << Tm->tm_sec
<< "\n"<<endl;
tm* localTm = std::localtime(&utcTimestamp);
time_t localTimestamp = std::mktime(localTm);
cout<<"std::time时间戳后，localtime再mktime：\n"<<localTimestamp<<std::endl;
cout << "具体为："
<< (localTm->tm_year + 1900) << "-" // 年份从1900年开始计数，所以需要加上1900
<< std::setw(2) << std::setfill('0') << (localTm->tm_mon + 1) << "-" // 月份从0开始计数，所以需要加上1，并使用setw和setfill来格式化输出
<< std::setw(2) << std::setfill('0') << localTm->tm_mday << " "
<< std::setw(2) << std::setfill('0') << localTm->tm_hour << ":"
<< std::setw(2) << std::setfill('0') << localTm->tm_min << ":"
<< std::setw(2) << std::setfill('0') << localTm->tm_sec
<< std::endl;
}
我的问题叙述：
std::time是UTC时间戳，比如值是X
而gmtime得到的结构体具体时间表示是北京时间减去8h，再mktime后，值是X-28800，
而localtime得到的结构体具体时间表示是北京时间，再mktime是X
这里单独看gmtime和localtime都对，但相当大的问题就是为啥std：：time得到的时间戳是X，不应该是X-28800吗？或者说
代码输出的两个具体时间为先是UTC时间，后是北京时间，没错，但为啥std::time得到的时间戳会与北京时间戳相同
注意右下角时间，开始解释，多亏Deepseek，我一直以为大模型都是深度解答，一开始还不知道deepseek联网回答有啥好处，豆包最垃圾但也经常看到联网搜索，
回忆ACM深黑幻想Deep Dark Fantasy 集美大学 海洋美术学院 clj打星参赛
Deepseek原汁原味解答太详细了，没看完就懂了，先附上原文： —— Deepseek回答的内容确实与众不同，更像是一个代入你第一人称的思考过程，与豆包、知乎直答、百度文心、通义千问都不一样
嗯，我现在得仔细看看这个问题。用户说运行代码后，两个具体时间一个是UTC时间，另一个是北京时间，这没问题。但为什么std::time得到的时间戳会和北京时间的时间戳相同呢？
首先，我需要理解代码的结构。代码里用了C++的ctime库来处理时间。用户首先用std::time获取当前的UTC时间戳utcTimestamp，然后分别用gmtime和localtime转换这个时间戳，再转换成tm结构体，接着用mktime转换回来得到新的时间戳Time和localTimestamp。然后输出这两个时间的具体日期时间和时间戳。
用户的问题是，为什么std::time得到的utcTimestamp和之后用localtime加mktime得到的localTimestamp是相同的？或者说，用户可能认为std::time返回的是UTC的时间戳，而北京时间是UTC+8，所以时间戳应该不同？
不过时间戳（time_t）通常表示的是自纪元（1970-01-01 00:00:00 UTC）以来的秒数，无论时区如何，同一时刻的时间戳是相同的。比如，不管你在哪个时区，当前的时间戳都是一样的，因为它基于UTC。例如，当北京时间是下午3点（UTC+8），对应的UTC时间是上午7点，此时的时间戳是相同的，因为它们代表同一时刻。
那问题中的代码，用户可能误解了std::time返回的是本地时间的时间戳，但实际不是。std::time返回的是当前的系统时间，通常系统内部是以UTC时间戳存储的。所以，无论用户所在的时区如何，这个时间戳的值都是相对于UTC的。而localtime函数将这个UTC时间戳转换为本地时间的tm结构体，而gmtime则保持UTC时间的tm结构体。
在代码中，用户首先用gmtime处理utcTimestamp得到Tm，然后用mktime转换这个tm结构体。这里可能存在问题，因为mktime函数假设tm结构体是本地时间，而不是UTC时间。所以，当用gmtime得到的UTC时间tm结构体，再用mktime处理时，会被当作本地时间来转换回时间戳，这可能导致错误的时间戳。例如，假设当前UTC时间是X，gmtime得到的tm结构体是X对应的UTC时间，但mktime认为这个tm结构体是本地时间，于是会将其转换为对应的UTC时间戳，这样会加上时区偏移，导致结果不正确。
比如，如果当前UTC时间是1620000000（假设对应2021-05-03 00:00:00 UTC），而本地时区是UTC+8，那么localtime会将这个时间戳转换为2021-05-03 08:00:00的tm结构体。用gmtime得到的tm结构体则是2021-05-03 00:00:00。当用mktime处理gmtime得到的tm结构体时，mktime认为这个tm结构体是本地时间，所以它会把2021-05-03 00:00:00本地时间转换为UTC时间戳，即减去8小时，得到1620000000 - 8*3600 = 1619712000。这样转换后的Time就会比原来的utcTimestamp小8小时的值。但实际运行中，用户可能发现Time的值和utcTimestamp不同，而localTimestamp则和utcTimestamp相同？
但用户代码中的输出显示，当使用gmtime后再mktime得到的Time可能与原utcTimestamp不同，而使用localtime后再mktime得到的localTimestamp等于原utcTimestamp？这可能吗？
比如，假设当前时间戳是T，代表UTC时间的某个时刻。gmtime(&T)会给出UTC时间的tm结构体。然后，mktime将这个tm结构体视为本地时间，转换为时间戳。假设本地时区是UTC+8，那么当tm结构体表示的是UTC时间的日期时间（比如12:00 UTC），但mktime认为这是本地时间，即12:00 UTC+8，相当于UTC时间04:00，所以转换后的时间戳会是T - 8小时。这样，Time会比原来的T小8小时。而localTm是localtime(&T)，即转换为本地时间（UTC+8），然后用mktime转换，此时mktime认为tm结构体是本地时间，所以正确转换回时间戳T。所以localTimestamp应该等于原来的T？
这可能就是为什么用户看到localTimestamp和utcTimestamp相同，而Time不同。这个时候用户的问题在于，为什么std::time得到的utcTimestamp和经过localtime再mktime得到的localTimestamp相同。这是因为当使用localtime将时间戳转换为本地时间的tm结构体，再用mktime转换回来时，mktime处理本地时间的tm结构体会正确还原为原来的时间戳。而gmtime得到的UTC时间tm结构体被错误地当作本地时间处理，导致转换后的时间戳与实际不符。
总结来说，时间戳本身是UTC的，和时区无关。当用localtime转换时间戳为本地时间的tm结构体，再用mktime处理这个tm结构体，会得到原来的时间戳。而用gmtime转换时间戳为UTC的tm结构体，再用mktime处理（此时mktime认为tm结构体是本地时间），会导致转换后的时间戳等于原时间戳减去时区偏移量。因此，在用户的代码中，localTimestamp等于utcTimestamp，而Time可能等于utcTimestamp减去时区偏移后的时间戳。
所以用户的问题可能在于，为什么std::time得到的时间戳和经过localtime再mktime后的时间戳相同。因为这两个操作其实是可逆的，而gmtime后再用mktime则会导致时区转换的问题，所以结果不同。因此，std::time得到的原始时间戳是UTC的，而经过正确的本地时间转换后再用mktime恢复，时间戳保持不变。因此，用户看到的两个时间戳中，使用localtime再mktime得到的localTimestamp与原始utcTimestamp相同，而gmtime后的则不同。
代码中时间戳相同的原因是
std::time返回的是基于UTC的绝对时间戳，而std::localtime和std::mktime的组合会正确处理时区偏移，最终恢复原始时间戳。具体分析如下：
关键点解析：
时间戳的本质：
std::time_t表示自 UTC 1970-01-01 00:00:00 以来的秒数，与时区无关。无论本地时区如何，同一时刻的时间戳值唯一。例如，北京时间（UTC+8）和UTC时间相差8小时，但对应的时间戳相同。
std::gmtime和std::localtime的区别：
std::gmtime：将时间戳转换为 UTC时间 的tm结构体。
std::localtime：将时间戳转换为 本地时间 的tm结构体（考虑时区）。
std::mktime的行为：
std::mktime假设输入的tm结构体是本地时间，将其转换为时间戳（UTC值）。因此：
若输入的
tm是本地时间（通过localtime生成），mktime能正确恢复原始时间戳。若输入的
tm是UTC时间（通过gmtime生成），mktime会错误地将其视为本地时间，导致时间戳计算错误。
代码行为解释：
std::time获取时间戳：time_t utcTimestamp = std::time(nullptr); // 返回当前UTC时间戳
std::localtime+std::mktime的组合：tm* localTm = std::localtime(&utcTimestamp); // 转换为本地时间的 tm 结构体 time_t localTimestamp = std::mktime(localTm); // 将本地时间恢复为原始时间戳
由于
mktime正确处理本地时间，localTimestamp等于原始的utcTimestamp
std::gmtime+std::mktime的组合：tm* Tm = std::gmtime(&utcTimestamp); // 转换为UTC时间的 tm 结构体 time_t Time = std::mktime(Tm); // 错误：将UTC时间误认为本地时间
假设本地时区为 UTC+8，
mktime会将Tm（UTC时间）当作本地时间，并减去8小时得到错误的时间戳。
示例验证（假设本地时区为 UTC+8）：
原始时间戳：
utcTimestamp = 1620000000（UTC 2021-05-03 00:00:00）。
std::localtime处理：
localTm表示北京时间 2021-05-03 08:00:00（UTC+8）。
mktime(localTm)将其转换为 UTC 时间戳1620000000（正确）。
std::gmtime处理：
Tm表示 UTC 时间 2021-05-03 00:00:00。
mktime(Tm)误认为Tm是本地时间（即 UTC+8 的 00:00:00），实际对应的 UTC 时间为 2021-05-02 16:00:00，时间戳为1619904000（错误）。
结论：
std::time返回的时间戳始终是UTC值，与本地时区无关。
localtime+mktime的组合能正确恢复原始时间戳，因为二者协同处理了时区偏移。
gmtime+mktime的组合会产生错误时间戳，因mktime错误解释了tm结构体的时区。
根据上面我的问题叙述那里，导致我一直以为，std::time是本地时间，因为那样一切就都合理了，但其实std::time就是UTC时间，
localtime会转化为时间形式结构体，且依据本地时间做UTC+8，再mktime时，会认为结构体是本地时间，所以会减去8h，所以localtime + mktime的组合会等于UTC时间。
gmtime会转化为时间形式结构体，只是UTC时间，再mktime，会认为结构体是本地时间，所以会减去8h，所以gmtime + mktime的组合会等于UTC时间 - 8h。
唉，早用deepseek何苦浪费了我这么多天的时间，不过“吃7个烧饼不是第7个饱的，是有前六个垫底”
最后为了清晰，让这件事凸显出来，见我硬着头皮搞写的代码
#include <iostream>
#include <ctime>
#include<iomanip>
using namespace std;
int main() {
// 获取当前的UTC时间戳
std::time_t utcTimestamp = std::time(nullptr);
cout<<"std::time：\n"<<utcTimestamp<<"\n"<<endl;
tm* Tm = std::gmtime(&utcTimestamp);
time_t Time = std::mktime(Tm);
cout<<"std::time时间戳后，gmtime再mktime：Time:\n"<<Time<<"\n"<<endl;
cout << "具体为："
<< (Tm->tm_year + 1900) << "-" // 年份从1900年开始计数，所以需要加上1900
<< std::setw(2) << std::setfill('0') << (Tm->tm_mon + 1) << "-" // 月份从0开始计数，所以需要加上1，并使用setw和setfill来格式化输出
<< std::setw(2) << std::setfill('0') << Tm->tm_mday << " "
<< std::setw(2) << std::setfill('0') << Tm->tm_hour << ":"
<< std::setw(2) << std::setfill('0') << Tm->tm_min << ":"
<< std::setw(2) << std::setfill('0') << Tm->tm_sec
<< "\n"<<endl;
Tm = std::gmtime(&Time);
cout << "具体为："
<< (Tm->tm_year + 1900) << "-" // 年份从1900年开始计数，所以需要加上1900
<< std::setw(2) << std::setfill('0') << (Tm->tm_mon + 1) << "-" // 月份从0开始计数，所以需要加上1，并使用setw和setfill来格式化输出
<< std::setw(2) << std::setfill('0') << Tm->tm_mday << " "
<< std::setw(2) << std::setfill('0') << Tm->tm_hour << ":"
<< std::setw(2) << std::setfill('0') << Tm->tm_min << ":"
<< std::setw(2) << std::setfill('0') << Tm->tm_sec
<< "\n"<<endl;
}这里第二次会输出一个比UTC时间还少8h的时间表示，至此大概懂了
至此理解了时间戳这玩意，顺便捋顺下过程中遇到的问题
1、
setw 和 setfill 是 C++ 标准库 <iomanip> 中的流操纵符，setw 用于设置输出的字段宽度，setfill 用于指定当输出内容长度小于设定宽度时填充的字符，例如 cout << setfill('0') << setw(5) << 12; 会输出 00012。std::tm* localTm 中 localTm 是一个指向 std::tm 类型结构体的指针，std::tm 是 C++ 标准库 <ctime> 里用于表示日历时间的结构体，包含年、月、日、时、分、秒等时间信息 mktime时，
const std::tm* utcTm = std::gmtime(&utcTimestamp);
double differenceInSeconds = difftime(mktime(utcTm), mktime(localTm)); 这段会报错，error: invalid conversion from 'const tm*' to 'tm*' [-fpermissive]
这是因为 std::gmtime 返回的是一个常量指针 const std::tm*，而 std::mktime 需要一个非常量指针 std::tm* 来修改其内容。我们需要先复制 std::gmtime 返回的对象，然后再传递给 std::mktime。
#include <iostream>
#include <ctime>
#include <iomanip>
int main() {
// 获取当前 UTC 时间戳
std::time_t utcTimestamp = std::time(nullptr);
// 将 UTC 时间戳转换为 UTC 时间结构体
const std::tm* utcTmConst = std::gmtime(&utcTimestamp);
std::cout << "UTC 时间: " << std::put_time(utcTmConst, "%F %T") << std::endl;
// 复制 UTC 时间结构体以便我们可以对其进行修改
std::tm utcTm(*utcTmConst);
// 将 UTC 时间戳转换为本地时间结构体
std::tm* localTm = std::localtime(&utcTimestamp);
// 使用 mktime 函数将 UTC 时间结构体转换回时间戳
std::time_t utcConvertedBackToTimestamp = std::mktime(&utcTm);
// 使用 mktime 函数将本地时间结构体转换回时间戳
std::time_t localTimestamp = std::mktime(localTm);
// 计算时间戳和本地时间的差值
std::time_t difference = localTimestamp - utcConvertedBackToTimestamp;
std::cout << "UTC 时间戳: " << utcTimestamp << std::endl;
std::cout << "UTC 时间: " << std::put_time(utcTmConst, "%F %T") << std::endl;
std::cout << "本地时间: " << std::put_time(localTm, "%F %T") << std::endl;
std::cout << "UTC 和本地时间的差值（秒）: " << difference << std::endl;
}const std::tm* utcTmConst = std::gmtime(&utcTimestamp); 这一行使用了 const 关键字，下面为你详细解释这么做的原因：
std::gmtime 返回的 std::tm 结构体是静态分配的，对其进行修改可能会引发不可预期的后果，例如影响后续对 std::gmtime 或 std::localtime 的调用结果。使用 const 修饰返回的指针，能防止意外修改这个静态对象，保证程序的正确性和稳定性。
解释新玩意：
在 C++ 里，std 是标准库命名空间（namespace）的名称，而 std::put_time 是 <iomanip> 头文件中定义的一个流操纵符，用于将时间信息按照指定的格式输出。
注意：
此代码的中文输出注释可以看出意图，而某些输出并不是想要的结果，如果理解前面deepseek解释的，就会明白，不再说了。（提一句，那个差值，其实不是本地和UTC的差，其实是UTC和UTC-8的差，另外UTC时间变了是因为）
疑惑：
put_timecodeblock始终无法输出，而VS就行。查了半天
说cmd用命令行g++ -std=c++20 testUntitled1.cpp -o也不行，你妈的我都老早之前就弄成C++20了
豆包从底层到编译器到mingw版本，各种奇奇怪怪的烦人问题也没解决，不管了
显式格式字符串：使用%Y-%m-%d %H:%M:%S代替%F %T，确保兼容性。
std::cout << std::put_time(utcTmConst, "%Y-%m-%d %H:%M:%S") << std::endl;完美解决
但是问Deepseek为啥的时候，
我用gcc -v发现是gcc version 14.2.0 (GCC)版本，但为何%F%T不行，%Y-%m-%d %H:%M:%S就行
他有崩溃了，唉
妈逼的每天只能用一次吗？
通义千问说C++20标准，不代表支持-std=c99，且说%F这玩意都是C的时间表示形式
#include <iostream>
#include <ctime>
#include <iomanip>
int main() {
std::time_t utcTimestamp = std::time(nullptr);
const std::tm* utcTmConst = std::gmtime(&utcTimestamp);
std::cout << std::put_time(utcTmConst, "%F %T") << std::endl;
// std::cout << std::put_time(utcTmConst, "%Y-%m-%d %H:%M:%S") << std::endl;
}
但第二次的UTC时间居然是本地时间，我搞不懂，deepseek解释的东西好像已经有点超出我学的东西了，附上，略过吧，以后有空再看
好的，我现在得仔细看看这个问题。用户提供的代码里，第二次输出UTC时间的时候，显示的却是本地时间，这是为什么呢？让我一步一步来分析。
首先，代码的大致流程是这样的：
1. 获取当前的时间戳，使用`std::time(nullptr)`，这应该返回当前的UTC时间戳。
2. 用`std::gmtime`把这个时间戳转换为UTC的tm结构体指针，这里用的是`const std::tm*`，所以可能不会被修改。
3. 第一次输出这个UTC时间，用户说这时候显示正确。
4. 复制这个结构体到utcTm变量，可能是为了修改？
5. 然后用`std::localtime`得到本地时间的tm结构体。
6. 之后用`mktime`将复制的utcTm转换回时间戳，得到utcConvertedBackToTimestamp。
7. 再用`mktime`处理本地时间结构体，得到localTimestamp。
8. 计算两者的差值，并输出相关的时间信息。
问题出在第二次输出UTC时间的时候，结果变成了本地时间。那可能是什么原因？
首先，我需要确认各个步骤中的函数作用。比如，`std::gmtime`返回的是UTC时间的结构体，而`std::localtime`返回的是本地时间的结构体。然后，`mktime`函数的作用是将tm结构体转换为时间戳，但它会认为这个tm结构体是本地时间，而不是UTC时间。这可能是一个关键点。
比如，当用户复制了utcTmConst指向的结构体到utcTm变量后，调用`std::mktime(&utcTm)`。这里的问题在于，`mktime`函数会把传入的tm结构体当作本地时间来解释，所以即使这个结构体原本是UTC时间，转换后的时间戳会被视为本地时间对应的UTC时间戳。这可能引起错误。
比如，假设原来的utcTm是UTC时间的结构体，比如2024-05-21 12:00:00。然后，当调用mktime的时候，系统会认为这个tm结构体是本地时间，然后转换为对应的UTC时间戳。如果本地时区是UTC+8，那么这时候转换后的时间戳相当于UTC+8时间的2024-05-21 12:00:00对应的UTC时间戳，也就是原UTC时间减去8小时的时间戳。这可能就会导致计算出来的utcConvertedBackToTimestamp并不是原来的utcTimestamp，而是被错误转换后的值。
但这里用户的问题不是关于转换后的时间戳是否正确，而是第二次输出的UTC时间为什么会变成本地时间。这可能和后面的操作有关吗？
再来看输出的部分。第一次输出的时候，用的是utcTmConst，也就是通过gmtime得到的结构体，输出正确。第二次输出同样用的是utcTmConst，但用户发现这时候输出的时间变成了本地时间。这似乎不可能，因为utcTmConst是指向gmtime的结果，而gmtime返回的是静态分配的结构体，可能被后续的调用覆盖了？
这里可能存在一个关键点：std::gmtime和std::localtime返回的是指向静态内部存储的指针，这些函数可能共享同一个静态结构体。因此，当后续调用这些函数时，可能会覆盖之前的结果。例如，当调用std::localtime的时候，可能会覆盖之前由std::gmtime返回的静态结构体。所以，此时utcTmConst指针指向的内容可能已经被修改了，导致第二次输出时显示的是本地时间而不是原来的UTC时间。
这是可能的。例如，在某些实现中，std::gmtime和std::localtime可能共享同一个静态缓冲区。因此，当调用std::localtime后，之前由std::gmtime返回的指针所指向的内容会被覆盖。所以，当用户第二次输出utcTmConst时，实际上该指针指向的内容已经被后面的localtime调用修改了，导致输出的是本地时间。
这样的话，第一次输出UTC时间时正确，但之后调用了localtime，这会覆盖静态缓冲区，导致utcTmConst指向的内容变成了本地时间。所以第二次输出的时候，显示的是本地时间而不是原来的UTC时间。
所以问题的根源在于，用户保存了gmtime返回的指针，之后调用了localtime，这改变了那个指针指向的内容，导致后续使用该指针时数据被覆盖。
验证这个猜测，可以查看C++标准中对gmtime和localtime的描述。根据C++标准，这些函数（继承自C标准库）可能会返回指向静态内部存储的指针，并且每次调用可能会覆盖该存储。因此，在调用这些函数时，如果之前保存了返回的指针，而后续又调用了另一个函数（如gmtime之后调用localtime），则之前的指针内容可能被覆盖。
例如，假设在代码中：
std::tm* localTm = std::localtime(&utcTimestamp);
这一步会修改gmtime所使用的静态缓冲区，导致utcTmConst指向的结构体被覆盖为localtime的结果。因此，当在最后再次输出std::put_time(utcTmConst, ...)时，实际上输出的是localtime的结果，即本地时间。
所以，第二次输出UTC时间的时候，虽然代码里用的是utcTmConst，但由于该指针指向的内容已经被localtime的调用覆盖，所以实际输出的是本地时间。
如何解决这个问题呢？通常的做法是，在调用gmtime或localtime之后，立即复制结构体的内容到另一个变量，而不是保存指针。例如，用户代码中已经复制了utcTmConst到utcTm变量，这是一个好的做法。但后续在输出的时候，用户仍然使用原来的指针utcTmConst，这时候这个指针已经被覆盖了。正确的做法应该是，在第一次调用gmtime之后，立即将结构体的内容复制到另一个变量，之后的操作都基于这个副本。
例如，修改代码如下：
std::time_t utcTimestamp = std::time(nullptr);
std::tm utcTm = *std::gmtime(&utcTimestamp); // 复制到本地变量
std::cout << "UTC 时间: " << std::put_time(&utcTm, "%F %T") << std::endl;
这样，即使之后调用了localtime，utcTm的内容不会被修改。而原来的代码中，虽然用户复制了utcTmConst指向的结构体到utcTm变量中，但输出的时候还是用了utcTmConst，这可能在之后被覆盖。
在用户的代码中，第一次输出的时候是正确的，因为此时还没有调用localtime。但在调用localtime之后，utcTmConst指向的结构体可能已经被修改了，导致第二次输出的时候错误。
因此，用户应该将第一次得到的UTC时间结构体的内容复制到自己的变量中，并在输出时使用该副本，而不是再次使用utcTmConst指针。例如，修改代码，将第一次的UTC时间结构体保存到utcTm变量中，之后输出时使用这个变量的地址。
总结问题原因：用户在使用gmtime获取UTC时间结构体后，保存了该指针utcTmConst。之后调用localtime，导致该指针指向的内容被覆盖。因此，第二次输出utcTmConst时，内容已经被修改为本地时间，导致输出错误。
在C++标准库中，
std::gmtime和std::localtime返回指向静态内部缓冲区的指针，且这些函数共享该缓冲区。当调用其中一个函数后，再调用另一个时，静态缓冲区会被覆盖。问题分析：
首次输出UTC时间：调用
std::gmtime后，utcTmConst指向静态缓冲区中的UTC时间，输出正确。调用
std::localtime：此时静态缓冲区的内容被覆盖为本地时间。第二次输出UTC时间：虽然代码仍使用
utcTmConst，但它指向的缓冲区已被修改为本地时间，因此输出错误。解决方案：
立即复制
tm结构体到独立变量中，避免后续调用覆盖数据：std::time_t utcTimestamp = std::time(nullptr); std::tm utcTm = *std::gmtime(&utcTimestamp); // 复制到本地变量 std::cout << "UTC 时间: " << std::put_time(&utcTm, "%F %T") << std::endl; // 后续操作不再使用 utcTmConst，改用 utcTm修改后的代码示例：
#include <iostream> #include <ctime> #include <iomanip> int main() { std::time_t utcTimestamp = std::time(nullptr); // 复制 UTC 时间结构体到独立变量 std::tm utcTm = *std::gmtime(&utcTimestamp); std::cout << "UTC 时间: " << std::put_time(&utcTm, "%F %T") << std::endl; // 复制本地时间结构体到独立变量 std::tm localTm = *std::localtime(&utcTimestamp); // 转换回时间戳时注意 mktime 的时区处理 std::time_t utcConvertedBackToTimestamp = std::mktime(&utcTm); // 此处逻辑可能有问题 std::time_t localTimestamp = std::mktime(&localTm); std::time_t difference = localTimestamp - utcConvertedBackToTimestamp; // 输出时使用独立变量的地址 std::cout << "UTC 时间: " << std::put_time(&utcTm, "%F %T") << std::endl; std::cout << "本地时间: " << std::put_time(&localTm, "%F %T") << std::endl; std::cout << "UTC 和本地时间的差值（秒）: " << difference << std::endl; }关键点说明：
静态缓冲区覆盖：
std::gmtime和std::localtime共享同一块内存，后续调用会覆盖之前的结果。
mktime的行为：mktime将tm结构体视为本地时间，若直接传入UTC时间结构体会导致转换错误。正确做法需调整时区或使用其他方法。数据独立性：通过立即复制结构体到独立变量，确保后续操作不受其他函数调用影响。
总结：
问题的根本原因是静态缓冲区的覆盖，通过复制结构体到独立变量可避免此问题。同时需注意
mktime的时区处理逻辑是否正确。
#include <iostream>
#include <ctime>
#include <iomanip>
using namespace std;
int main() {
std::time_t utcTimestamp = std::time(nullptr);
const std::tm* utcTmConst = std::gmtime(&utcTimestamp);
std::cout << "UTC 时间: " << std::put_time(utcTmConst, "%Y-%m-%d %H:%M:%S") << std::endl;
// std::tm utcTm(*utcTmConst);
std::tm* localTm = std::localtime(&utcTimestamp);
// std::time_t utcConvertedBackToTimestamp = std::mktime(&utcTm);
std::cout << "UTC 时间: " << std::put_time(utcTmConst, "%Y-%m-%d %H:%M:%S") << std::endl;
}先回顾静态存储区，堆栈存储先不管，我也忘了是啥了，反正全局变量、静态static声明的变量，都放在这里std::tm* localTm = std::localtime(&utcTimestamp);会覆盖const std::tm* utcTmConst = std::gmtime(&utcTimestamp);的内容，并不是说静态区只有一块，错误理解：gmtime不改变utcTimestamp，将utcTimestamp弄成结构体的值放入utcTmConst，然后localtime使得UTC+8的结构体值放入localTm，咋就改变utcTimestamp了？要知道，C++ 标准规定std::gmtime和std::localtime返回的指针指向一个静态存储期的对象。这意味着这些函数返回的指针指向的内存区域在程序的整个生命周期内都存在，不会因为函数调用结束而被销毁。通俗叙述就是，gmtime和localtime函数都在std里定义好的，且类型是tm指针，表现形式是时间形式结构体，且底层把这俩函数都指向同一个静态存储区，即同一个程序中有如下两句话：const std::tm* utcTmConst = std::gmtime(&utcTimestamp);std::tm* localTm = std::localtime(&utcTimestamp);则utcTmConst和loaclTm这两个tm*类型指针，都指向同一个存储区，记作A区，utcTmConst指针指向的是A区，将A区值弄成UTC结构体，localTm也是指向A区，会将A区值弄成本地时间的结构体？ 那我有个疑惑，*tm这种是可以改变存储区值的？回答：
std::tm*这种指针类型可以改变其所指向存储区的值。指针本质上就是一个变量，它存储的是内存地址，通过指针可以对其所指向的内存区域进行读写操作。回顾指针举个例子：
例如int num = 10; int* ptr = # *ptr = 20;，这里ptr是指针指向num存储区，通过*ptr = 20修改其指向存储区的值，就如同std::tm*可修改指向std::tm结构体存储区的值。一般建议将std::gmtime返回值用const修饰，因为std::gmtime返回的std::tm*指向的是静态存储区内容且为UTC，修改它可能引发问题且标准没规定可修改；而std::localtime返回值可加可不加const改进：用Deepseek 说的std::time_t utcTimestamp = std::time(nullptr); std::tm utcTm = *std::gmtime(&utcTimestamp); // 复制到本地变量 std::cout << "UTC 时间: " << std::put_time(&utcTm, "%F %T") << std::endl; // 后续操作不再使用 utcTmConst，改用 utcTm
std::tm utcTm = *std::gmtime(&utcTimestamp);将std::gmtime返回的静态std::tm结构体内容复制到本地变量utcTm中，后续用utcTm输出就不会受std::localtime影响，区别：
std::tm* localTm = std::localtime(&utcTimestamp);是将std::localtime返回的指向静态std::tm结构体的指针赋给指针变量localTm；std::tm localTm = *std::localtime(&utcTimestamp);是先调用std::localtime(&utcTimestamp)获取指向静态std::tm结构体的指针，再通过解引用操作符*取出该结构体对象，然后用这个结构体对象对新定义的std::tm类型的局部变量localTm进行拷贝初始化，将静态存储区中存储的本地时间结构体内容复制到localTm中，避免后续操作覆盖数据。之前都是std::put_time(utcTmConst，避免覆盖后用std::put_time(&utcTm。之前utcTmConst是指向静态存储区std::tm对象的指针，所以直接将其作为std::put_time的参数；而避免覆盖采用复制操作得到的utcTm是std::tm类型的局部变量，std::put_time函数需要接收指向std::tm的指针，因此要通过取地址符&得到utcTm的地址（即&utcTm）作为参数传入。至此可以理解上面Deepseek的代码了，此文搜“修改后的代码示例”那么转成codeblock可行的代码，精简后为#include <iostream> #include <ctime> #include <iomanip> using namespace std; int main() { time_t utcTimestamp = time(nullptr); // 复制 UTC 时间结构体到独立变量 tm utcTm = *std::gmtime(&utcTimestamp); cout << "UTC:"<< put_time(&utcTm, "%Y-%m-%d %H:%M:%S")<<endl; // 复制本地时间结构体到独立变量 tm localTm = *std::localtime(&utcTimestamp); // 转换回时间戳时注意 mktime 的时区处理 // time_t utcConvertedBackToTimestamp = mktime(&utcTm); // 此处逻辑可能有问题 // time_t localTimestamp = mktime(&localTm); // 输出时使用独立变量的地址 cout << "UTC:"<<put_time(&utcTm, "%Y-%m-%d %H:%M:%S") <<endl; cout << "本地:" <<put_time(&localTm, "%Y-%m-%d %H:%M:%S")<<endl; }
这里我又想个事：
1、目前两种写法
#include <iostream> #include <ctime> #include <iomanip> using namespace std; int main() { time_t utcTimestamp = time(nullptr); tm utcTm = *std::gmtime(&utcTimestamp); cout << "UTC:"<< put_time(&utcTm, "%Y-%m-%d %H:%M:%S")<<endl; tm localTm = *std::localtime(&utcTimestamp); cout << "UTC:"<<put_time(&utcTm, "%Y-%m-%d %H:%M:%S") <<endl; cout << "本地:" <<put_time(&localTm, "%Y-%m-%d %H:%M:%S")<<endl; } #include <iostream> #include <ctime> #include <iomanip> using namespace std; int main() { time_t utcTimestamp = time(nullptr); tm* utcTm = gmtime(&utcTimestamp); cout << "UTC:"<< put_time(utcTm, "%Y-%m-%d %H:%M:%S")<<endl; tm* localTm = localtime(&utcTimestamp); cout << "UTC:"<<put_time(utcTm, "%Y-%m-%d %H:%M:%S") <<endl; cout << "本地:" <<put_time(localTm, "%Y-%m-%d %H:%M:%S")<<endl; }首先要知道的是，tm变量是用于存储分解后的日期和时间信息。它的定义大致如下：
struct tm { int tm_sec; // 秒，范围从 0 到 59 int tm_min; // 分，范围从 0 到 59 int tm_hour; // 小时，范围从 0 到 23 int tm_mday; // 一个月中的第几天，范围从 1 到 31 int tm_mon; // 月份，范围从 0 到 11（0 表示 1 月） int tm_year; // 自 1900 年起的年数 int tm_wday; // 一周中的第几天，范围从 0 到 6（0 表示星期日） int tm_yday; // 一年中的第几天，范围从 0 到 365 int tm_isdst; // 夏令时标志，正数表示使用夏令时，0 表示不使用，负数表示信息未知 };Q：我的理解， std::tm* localTm = std::localtime(&utcTimestamp); 是说，有个tm*类型的指针叫localTm，指向的是一个存储区叫做A区，通过localtime函数，使得A区的值，弄成了UTC结构体 std::tm localTm = *std::localtime(&utcTimestamp); 这句话，是弄了一个localTm变量？tm型即时间结构体形式型？然后赋值为UTC结构体的值？这个怎么理解？ 还有，第1种写法是公共拥有同一块存储区，第2种写法是分别开了两个变量，各自存储了结构体形式的值？那localtime和gmtime他们本来指向的存储区是啥？没值吗？
A：
std::tm* localTm = std::localtime(&utcTimestamp);：localTm是tm*类型指针，指向localtime函数返回的静态存储区（A 区），此存储区被localtime填充为本地时间对应的tm结构体内容，而非 UTC 结构体。std::tm localTm = *std::localtime(&utcTimestamp);：创建了一个std::tm类型的变量localTm，把localtime返回指针所指静态存储区里的tm结构体内容复制到localTm这个变量中，也就是把本地时间结构体值赋给它。- 第一种写法多个指针可能指向
localtime和gmtime返回的同一块静态存储区，在多线程环境可能有数据竞争问题；第二种写法是分别定义变量存储结构体值，各自独立。localtime和gmtime指向的静态存储区初始无有意义值，调用函数时，它们会根据传入的time_t类型时间戳，计算并填充对应（本地时间或 UTC 时间）的tm结构体值到该静态存储区。即指向的静态区里存的值，是最后一次的，没啥实际固定的意义，真正有意义的都已经分离存储到localTm和gmtime的tm变量里了2、之前的理解
localtime + mktime抵消那个还成立吗？一试便知
此文搜“附上”的第一个，那段代码，在后面加一个输出那段静态存储区，看看是不是会变，即把第一个Tm那个再复制到最下面，确实变了，符合新的这个认知
#include <iostream> #include <ctime> #include<iomanip> using namespace std; int main() { // 获取当前的UTC时间戳 std::time_t utcTimestamp = std::time(nullptr); cout<<"std::time：\n"<<utcTimestamp<<"\n"<<endl; // 将UTC时间戳转换为本地时间的tm结构体 tm* Tm = std::gmtime(&utcTimestamp); time_t Time = std::mktime(Tm); cout<<"std::time时间戳后，gmtime再mktime：Time\n"<<Time<<"\n"<<endl; cout << "具体为：" << (Tm->tm_year + 1900) << "-" // 年份从1900年开始计数，所以需要加上1900 << std::setw(2) << std::setfill('0') << (Tm->tm_mon + 1) << "-" // 月份从0开始计数，所以需要加上1，并使用setw和setfill来格式化输出 << std::setw(2) << std::setfill('0') << Tm->tm_mday << " " << std::setw(2) << std::setfill('0') << Tm->tm_hour << ":" << std::setw(2) << std::setfill('0') << Tm->tm_min << ":" << std::setw(2) << std::setfill('0') << Tm->tm_sec << "\n"<<endl; tm* localTm = std::localtime(&utcTimestamp); time_t localTimestamp = std::mktime(localTm); cout<<"std::time时间戳后，localtime再mktime：\n"<<localTimestamp<<std::endl; cout << "具体为：" << (localTm->tm_year + 1900) << "-" // 年份从1900年开始计数，所以需要加上1900 << std::setw(2) << std::setfill('0') << (localTm->tm_mon + 1) << "-" // 月份从0开始计数，所以需要加上1，并使用setw和setfill来格式化输出 << std::setw(2) << std::setfill('0') << localTm->tm_mday << " " << std::setw(2) << std::setfill('0') << localTm->tm_hour << ":" << std::setw(2) << std::setfill('0') << localTm->tm_min << ":" << std::setw(2) << std::setfill('0') << localTm->tm_sec << std::endl; cout << "具体为：" << (Tm->tm_year + 1900) << "-" // 年份从1900年开始计数，所以需要加上1900 << std::setw(2) << std::setfill('0') << (Tm->tm_mon + 1) << "-" // 月份从0开始计数，所以需要加上1，并使用setw和setfill来格式化输出 << std::setw(2) << std::setfill('0') << Tm->tm_mday << " " << std::setw(2) << std::setfill('0') << Tm->tm_hour << ":" << std::setw(2) << std::setfill('0') << Tm->tm_min << ":" << std::setw(2) << std::setfill('0') << Tm->tm_sec << "\n"<<endl; }3、那个有趣的事，此文搜“让这件事凸显出来”那段代码
#include <iostream> #include <ctime> #include<iomanip> using namespace std; int main() { // 获取当前的UTC时间戳 std::time_t utcTimestamp = std::time(nullptr); cout<<"std::time：\n"<<utcTimestamp<<"\n"<<endl; tm* Tm = std::gmtime(&utcTimestamp); time_t Time = std::mktime(Tm); cout<<"std::time时间戳后，gmtime再mktime：Time:\n"<<Time<<"\n"<<endl; cout << "具体为：" << (Tm->tm_year + 1900) << "-" // 年份从1900年开始计数，所以需要加上1900 << std::setw(2) << std::setfill('0') << (Tm->tm_mon + 1) << "-" // 月份从0开始计数，所以需要加上1，并使用setw和setfill来格式化输出 << std::setw(2) << std::setfill('0') << Tm->tm_mday << " " << std::setw(2) << std::setfill('0') << Tm->tm_hour << ":" << std::setw(2) << std::setfill('0') << Tm->tm_min << ":" << std::setw(2) << std::setfill('0') << Tm->tm_sec << "\n"<<endl; tm* TTm = std::gmtime(&Time); // Tm = std::gmtime(&Time); cout << "具体为：" << (Tm->tm_year + 1900) << "-" // 年份从1900年开始计数，所以需要加上1900 << std::setw(2) << std::setfill('0') << (Tm->tm_mon + 1) << "-" // 月份从0开始计数，所以需要加上1，并使用setw和setfill来格式化输出 << std::setw(2) << std::setfill('0') << Tm->tm_mday << " " << std::setw(2) << std::setfill('0') << Tm->tm_hour << ":" << std::setw(2) << std::setfill('0') << Tm->tm_min << ":" << std::setw(2) << std::setfill('0') << Tm->tm_sec << "\n"<<endl; }无论Tm还是新命名TTm，最后Tm都变了
也验证了gmtime就是操作同一个存储块
View Code某人为了学UNIX开发了LINUX 我为了学C++，，，写书？
gmtime函数VS会报错：'gmtime': This function or variable may be unsafe. Consider using gmtime_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
gmtime_s，#define _CRT_SECURE_NO_WARNINGS去掉警告，唉好烦啊~~~~(>_<)~~~~
Q：一句话解释tm* localTm = localtime(&now);
A：这句话定义了一个指向 tm 结构体的指针 localTm，并调用 localtime 函数将以秒为单位表示的当前时间 now 转换为本地时间，localtime 函数返回指向包含该本地时间信息的 tm 结构体的指针，然后将这个指针赋值给 localTm
###：
释怀
京杭不知道农发
WYH不知道什么叫全部动起来，什么叫国产化、统信
有时候不是农民文化水平不高，而是解释不清楚
为了学UNIX开发了LINUX
我为了学C++，，，，###：烦人豆包侧边栏总是鼠标滑过就展开，还回不去，直接屏蔽掉，需要再解开
doubao.com##.sidebar-UeSlOl.collapsed-Xorh_w.open-temporarily-MrUqNU
###：过年回家3天硬座，记录于微信，过年后继续回来学
###：豆包：以下所有问题不特殊说明都一句话回答，且全都用C++
###：VS就是个智障垃圾玩意
操！C 你！妈！ 的 傻逼VS的代码补全真他妈恶心，给残疾人用的吗？体验感没codeblock的十万分之一好用，我就加个注释，换做codeblock直接全选ctrl+shift+C就行，而VS不知道用啥，我想用/**/，结果他妈的强制性补全，删除又删不掉
- 关闭VS C++ 悬停提示
- 打开 Visual Studio 2022，点击顶部菜单栏中的 “工具”（Tools），在下拉菜单里选择 “选项”（Options）。
- 在弹出的 “选项” 对话框左侧列表中，展开 “文本编辑器”（Text Editor）。
- 展开 “C/C++”，接着选择 “高级”（Advanced）。
- 在右侧 “IntelliSense” 区域内，找到 “自动快速信息”（Auto Quick Info），将其值从 “True” 改为 “False” 。
- 点击 “确定” 保存设置。
快捷键：
###：初学我尽量写 using namespace std; 这样好处可以专注编程和代码思路，满片子绿色的std::真的傻逼，光有整齐的书写了，但过于无意义的追叙std::，相当耽误看代码理解代码
就像考试没写解一样，下次总会记得，但总写解或者总写std::太干扰理解代码了，还有就是这些关于时间戳的问题，我理解学了好久好久，收获是适应了这种C++各种std库函数，但有时候时间戳问题涉及底层编译器亦或是其他解释，就很烦，很想专注学代码看代码，反倒是他妈的搞了一堆工具，一堆环境，一堆编译器版本，系统时间，编译器版本，运行配置，编译器和工具链问题，狗屁问题，真的很难受
看了好几好几天的时间戳也终于才熟悉了几个gmtime、mktime、localtime、tm函数
###：
###：
浙公网安备 33010602011771号