C++时间管理

时间段

表示时间间隔，可以是秒，分钟，小时，微秒，毫秒，纳秒

头文件

#include<chrono>

using nanoseconds  = duration<long long, nano>;		//纳秒
using microseconds = duration<long long, micro>;	//微妙
using milliseconds = duration<long long, milli>;	//毫秒
using seconds      = duration<long long>;			//秒
using minutes      = duration<int, ratio<60>>;		//分钟
using hours        = duration<int, ratio<3600>>;    //小时

#include<chrono>
#include<iostream>
#include<thread>
using namespace std;
int main() {
	//时间类型是用duration这个模板类来描述的
	chrono::duration<long long, ratio<60>> dur;
	//using hours=duration<int,ratio<3600>>
	chrono::hours h(1);
	chrono::minutes m(1);
	//c++多线程中的休眠函数
	cout << "延迟1秒钟" << endl;
	this_thread::sleep_for(chrono::seconds(1));	//延时
	//用文本重载
	cout << "延迟3秒钟" << endl;
	this_thread::sleep_for(1s);

	//时间段之间允许直接进行运算符，不需要转换操作
	chrono::hours h1(1);
	chrono::seconds sec1(100);
	auto result = h1 - sec1;
	//count函数可以打印时间间隔多少秒
	cout << "时间间隔：" << result.count() << endl;

	return 0;
}

时钟

system_clock:获取时间点，需要转换成tim_t才能正确显示        

steady_clock:计时 类似秒表

high_resolution_clock:高精度时钟，相对来说比系统时钟更细致

#include<chrono>
#include<iostream>
#include<iomanip>	//格式换字符中有一个put_time函数打印时间
#include<thread>
using namespace std;
void test_system_clock() {
	//获取时间点
	chrono::system_clock::time_point result = chrono::system_clock::now();
	//时间点转化为可以显示的时间time_t类型
	time_t m_tm = chrono::system_clock::to_time_t(result);
	//time_t就是一个时间戳，自1970年过了多少秒了
	cout << m_tm << endl;
	//通过ctime当中的函数转换为字符串打印出来
	cout << ctime(&m_tm) << endl;		//c语言
	//C++通过put_time来进行打印时间，参数是tm类型
	std::tm* p = localtime(&m_tm);
	cout << "格式化时间" << " " << put_time(p, "%F %T") << endl;
	//c++通过时间段打印时间戳
	cout << "时间段打印时间戳" << result.time_since_epoch().count() << endl;
	chrono::system_clock::time_point end = chrono::system_clock::now();
	auto duration = end - result;
	cout << duration.count();
}
void test_steady_clock() {
	chrono::steady_clock::time_point startTime = chrono::steady_clock::now();
	this_thread::sleep_for(1s);
	chrono::steady_clock::time_point endTime = chrono::steady_clock::now();
	auto time = endTime - startTime;
	cout << "耗时" << time.count() << "ns" << endl;
	chrono::duration<double,ratio<1>> sec= endTime - startTime;
	cout << "耗时" << sec.count() << "s" << endl;
}
void test_high_resolution_clock() {
	chrono::high_resolution_clock::time_point startTime = chrono::steady_clock::now();
	this_thread::sleep_for(1s);
	chrono::high_resolution_clock::time_point endTime = chrono::steady_clock::now();
	auto time = endTime - startTime;
	cout << "耗时" << time.count() << "ns" << endl;
	chrono::duration<double, ratio<1>> sec = endTime - startTime;
	cout << "耗时" << sec.count() << "s" << endl;
}
int main() {
	test_system_clock();
	cout << endl;
	test_steady_clock();
	test_high_resolution_clock();
	return 0;
}

时钟类共用的一些函数

static time_point now()获取当前时间点

static time64_t to_time_t(const time_point x); 把时间点转化为time_t

time_point from_time_t(time_t x) 把time_t类型转换为time_point类型

时间转换

duration_cast是一个模板函数，不属于duration类

        浮点时长和整数时长之间可以直接隐式转换，其他情况要使用这个函数做转换。

time_point_cast是一个模板函数，不属于duration类

        存在精度丢失的ration转换，就必须使用time_point_cast函数转换。

#include<iostream>
#include<chrono>
#include<thread>
using namespace std;
/*
	duration_cast是一个模板函数，不属于duration类
*/
void test_duration_cast() {
	chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
	this_thread::sleep_for(1s);
	auto end = chrono::high_resolution_clock::now();
	chrono::milliseconds mtime = chrono::duration_cast<chrono::milliseconds>(end - start);
	cout << mtime.count() << "ms" << endl;
	// 浮点时长和整数时长之间可以直接隐式转换，其他情况要使用这个函数做转换。
	chrono::duration<double, ratio<1, 1000>> dtime = end - start;
	cout << dtime.count() << "ms" << endl;
}
//辅助打印函数
template<class Duration>void print_ms(const chrono::time_point<chrono::high_resolution_clock, Duration> time_point) {
	cout << time_point.time_since_epoch().count() << endl;
}
void test_time_point_cast() {
	using TIMEMS = chrono::time_point<chrono::high_resolution_clock, chrono::milliseconds>;
	TIMEMS time_point_sec(chrono::seconds(6));
	//秒到毫秒，不存在精度丢失，所以不用强转
	TIMEMS time_point_ms(time_point_sec);
	print_ms(time_point_ms);
	time_point_ms = TIMEMS(6789ms);
	using TIMESEC= chrono::time_point<chrono::high_resolution_clock, chrono::seconds>;
	TIMESEC time_sec;
	//time_sec = time_point_ms;		//报错
	time_sec = chrono::time_point_cast<chrono::seconds>(time_point_ms);
	print_ms(time_sec);
}

int main() {
	test_duration_cast();
	test_time_point_cast();



}

C++随机数

种子序列：是一个类，seed_seq

类似c语言的srand函数，用来设置范围。

size（）：检测种子个数

generate（）：通过内部算法把容器填充

param（）：拷贝赋值，把种子里的元素拷贝到一个容器

#include<iostream>
#include<random>
#include<functional>
#include<array>
using namespace std;
int main() {
	seed_seq seed = { 1,2,4,5,6,8,9 };
	cout << "size:" << seed.size() << endl;
	array<int, 7> arr;
	seed.param(arr.begin());
	cout << "param:";
	for (auto v : arr) {
		cout << v << "\t";
	}
	cout << endl;
	array<int, 7> arr2;
	seed.generate(arr2.begin(), arr2.end());
	cout << "generate:";
	for (auto v : arr2) {
		cout << v << "\t";
	}
	cout << endl;
	return 0;
}

随机数中的引擎适配器

shuffle_order_engine:乱序随机数引擎适配器

independent_bits_engine:独立位随机引擎适配器

discard_block_engine:丢弃块随机数引擎适配器

default_random_engine:默认随机数

#include<iostream>
#include<random>
#include<functional>
#include<chrono>
using namespace std;
int main() {
	//1.基本操作：生成随机数
	default_random_engine e;
	//可以用chrono也可以用c语言的time
	//e.seed((size_t)time(NULL));
	e.seed((size_t)chrono::high_resolution_clock::now().time_since_epoch().count());
	//high_resolution_clock::now()是time_point类型，而seed要unsigned int
	//生成随机数
	for (int i = 0; i < 3; i++) {
		cout << "随机数：" << e()%10 << "\t";
	}
	cout << endl;
	cout << "max:" << e.max() << endl;
	cout << "min:" << e.min() << endl;

	//2.分布和引擎的方式
	//统一分布
	uniform_int_distribution<int> duration(1, 6);
	cout << "uniform:" << duration(e) << endl;
	auto randDom = bind(duration, e);
	cout << randDom() << endl;

	//还有正态分布、线性同余等等

	//3了解部分
	//伪随机引擎实例化配上适配器
	//线性同余适配器	//x=(x*a+c)%m
	//适配器实例化产生
	linear_congruential_engine<size_t, 1, 2, 10>el;
	el.seed((size_t)time(nullptr));
	cout << "线性同余：" << el() << endl;

	knuth_b ee;
	mt19937_64 eee;
	cout << "梅森旋转：" << eee() << endl;


	return 0;
}