Chrono库

news2024/11/27 14:51:10

chrono库

C++11中提供了日期和时间相关的库chrono，通过chrono库可以很方便地处理日期和时间，为程序的开发提供了便利。chrono库主要包含三种类型的类：时间间隔duration、时钟clocks、时间点time point。

1.时间间隔duration

1.1常用类成员

duration表示一段时间间隔，用来记录时间长度，可以表示几秒、几分钟、几个小时的时间间隔。duration的原型如下：

// 定义于头文件 <chrono>
template<
    class Rep,
    class Period = std::ratio<1>
> class duration;
  • Rep：这是一个数值类型，用来表示时间段所经历的滴答（tick）数。若 Rep 是浮点数，则 duration 能使用小数描述时钟周期的数目。
  • Period：表示时钟的周期，它的原型如下：
// 定义于头文件 <ratio>
template<
    std::intmax_t Num,
    std::intmax_t Denom = 1
> class ratio;

ratio类表示每个时钟周期的秒数，其中第一个模板参数Num代表分子，Denom代表分母，该分母值默认为1，因此，ratio代表的是一个分子除以分母的数值，比如：ratio<2>代表一个时钟周期是2秒，ratio<60>代表一分钟，ratio<6060>代表一个小时，ratio<6060*24>代表一天。而ratio<1,1000>代表的是1/1000秒，也就是1毫秒，ratio<1,1000000>代表一微秒，ratio<1,1000000000>代表一纳秒。

为了方便使用，在标准库中定义了一些常用的时间间隔，比如：时、分、秒、毫秒、微秒、纳秒，它们都位于chrono命名空间下，定义如下：

类型 定义
纳秒：std::chrono::nanoseconds duration<Rep/至少 64 位的有符号整数类型/*, std::nano>*
微秒：std::chrono::microseconds duration<Rep/至少 55 位的有符号整数类型/*, std::micro>*
毫秒：std::chrono::milliseconds duration<Rep/至少 45 位的有符号整数类型/*, std::milli>*
秒： std::chrono::seconds duration<Rep/至少 35 位的有符号整数类型/*>*
分钟：std::chrono::minutes duration<Rep/至少 29 位的有符号整数类型/*, std::ratio<60>>*
小时：std::chrono::hours duration<Rep/至少 23 位的有符号整数类型/*, std::ratio<3600>>*

  • 例如，下面可以轻松的指定一些时间段：
chrono::seconds      twentySeconds(20); //20秒
chrono::hours        aDay(24);          //24小时
chrono::milliseconds oneMillisecond(1); //1毫秒
duration的算术运算
  • 下图列出了duration可以进行的算术运算。例如：
    • 你可以计算两个duration的和、差、积和商
    • 你可以加减tick，或加减其他duration
    • 你可以比较两个duration的大小

在这里插入图片描述

duration类还提供了获取时间间隔的时钟周期数的方法count()，函数原型如下：

constexpr rep count() const;
1.2类的使用

通过构造函数构造事件间隔对象示例代码如下：

#include <chrono>
#include <iostream>
using namespace std;
int main()
{
    chrono::hours h(1);                          // 一小时
    chrono::milliseconds ms{ 3 };                // 3 毫秒
    chrono::duration<int, ratio<1000>> ks(3);    // 3000 秒

    // chrono::duration<int, ratio<1000>> d3(3.5);  // error
    chrono::duration<double> dd(6.6);               // 6.6 秒

    // 使用小数表示时钟周期的次数
    chrono::duration<double, std::ratio<1, 30>> hz(3.5);
}
  • h(1)时钟周期为1小时，共有1个时钟周期，所以h表示的时间间隔为1小时
  • ms(3)时钟周期为1毫秒，共有3个时钟周期，所以ms表示的时间间隔为3毫秒
  • ks(3)时钟周期为1000秒，一共有三个时钟周期，所以ks表示的时间间隔为3000秒
  • d3(3.5)时钟周期为1000秒，时钟周期数量只能用整形来表示，但是此处指定的是浮点数，因此语法错误
  • dd(6.6)时钟周期为默认的1秒，共有6.6个时钟周期，所以dd表示的时间间隔为6.6秒
  • hz(3.5)时钟周期为1/30秒，共有3.5个时钟周期，所以hz表示的时间间隔为1/30*3.5秒

chrono库中根据duration类封装了不同长度的时钟周期（也可以自定义），基于这个时钟周期再进行周期次数的设置就可以得到总的时间间隔了（时钟周期 * 周期次数 = 总的时间间隔）。

#include <chrono>
#include <iostream>
int main()
{
    std::chrono::milliseconds ms{3};         // 3 毫秒
    std::chrono::microseconds us = 2*ms;     // 6000 微秒
    // 时间间隔周期为 1/30 秒
    std::chrono::duration<double, std::ratio<1, 30>> hz(3.5);
 
    std::cout <<  "3 ms duration has " << ms.count() << " ticks\n"
              <<  "6000 us duration has " << us.count() << " ticks\n"
              <<  "3.5 hz duration has " << hz.count() << " ticks\n";       
}

输出的结果为：

3 ms duration has 3 ticks
6000 us duration has 6000 ticks
3.5 hz duration has 3.5 ticks
  • ms时间单位为毫秒，初始化操作ms{3}表示时间间隔为3毫秒，一共有3个时间周期，每个周期为1毫秒
  • us时间单位为微秒，初始化操作2*ms表示时间间隔为6000微秒，一共有6000个时间周期，每个周期为1微秒
  • hz时间单位为秒，初始化操作hz(3.5)表示时间间隔为1/30*3.5秒，一共有3.5个时间周期，每个周期为1/30秒

由于在duration类内部做了操作符重载，因此时间间隔之间可以直接进行算术运算，比如我们要计算两个时间间隔的差值，就可以在代码中做如下处理：

#include <iostream>
#include <chrono>
using namespace std;

int main()
{
    chrono::minutes t1(10);
    chrono::seconds t2(60);
    chrono::seconds t3 = t1 - t2;
    cout << t3.count() << " second" << endl; // 540 second
}

在上面的测试程序中，t1代表10分钟，t2代表60秒，t3是t1减去t2，也就是60*10-60=540，这个540表示的时钟周期，每个时钟周期是1秒，因此两个时间间隔之间的差值为540秒。

注意事项：duration的加减运算有一定的规则，当两个duration时钟周期不相同的时候，会先统一成一种时钟，然后再进行算术运算，统一的规则如下：假设有ratio<x1,y1> 和 ratio<x2,y2>两个时钟周期，首先需要求出x1，x2的最大公约数X，然后求出y1，y2的最小公倍数Y，统一之后的时钟周期ratio为ratio<X,Y>。

#include <iostream>
#include <chrono>
using namespace std;

int main()
{
    chrono::duration<double, ratio<9, 7>> d1(3);
    chrono::duration<double, ratio<6, 5>> d2(1);
    // d1 和 d2 统一之后的时钟周期
    chrono::duration<double, ratio<3, 35>> d3 = d1 - d2;
}

对于分子6,、9最大公约数为3，对于分母7、5最小公倍数为35，因此推导出的时钟周期为ratio<3,35>

其他运算:

chrono::seconds twentySeconds(20); //20秒
chrono::hours   aDay(24);          //24小时
 
chrono::milliseconds ms;           //0毫秒
ms += twentySeconds + aDay;        //86400000毫秒
--ms;                              //86399999毫秒
ms *= 2;                           //172839998毫秒

2.时间点time point

chrono库中提供了一个表示时间点的类time_point，该类的定义如下：

// 定义于头文件 <chrono>
template<
    class Clock,
    class Duration = typename Clock::duration
> class time_point;

它被实现成如同存储一个 Duration 类型的自 Clock 的纪元起始开始的时间间隔的值，通过这个类最终可以得到时间中的某一个时间点。

  • Clock：此时间点在此时钟上计量
  • Duration：用于计量从纪元起时间的 std::chrono::duration 类型

time_point类的构造函数原型如下：

// 1. 构造一个以新纪元(epoch，即：1970.1.1)作为值的对象，需要和时钟类一起使用，不能单独使用该无参构造函数
time_point();
// 2. 构造一个对象，表示一个时间点，其中d的持续时间从epoch开始，需要和时钟类一起使用，不能单独使用该构造函数
explicit time_point( const duration& d );
// 3. 拷贝构造函数，构造与t相同时间点的对象，使用的时候需要指定模板参数
template< class Duration2 >
time_point( const time_point<Clock,Duration2>& t );

在这个类中除了构造函数还提供了另外一个time_since_epoch()函数，用来获得1970年1月1日到time_point对象中记录的时间经过的时间间隔（duration），函数原型如下：

duration time_since_epoch() const;

除此之外，时间点time_point对象和时间段对象duration之间还支持直接进行算术运算（即加减运算），时间点对象之间可以进行逻辑运算，具体细节可以参考下面的表格：

其中 tp 和 tp2 是time_point 类型的对象， dtn 是duration类型的对象。

描述 操作 返回值
*复合赋值(成员函数) operator+= tp += dtn this
*复合赋值(成员函数) operator-= tp -= dtn this
算术运算符(非成员函数) operator+ tp + dtn a time_point value
算术运算符(非成员函数) operator+ dtn + tp a time_point value
算术运算符(非成员函数) operator- tp - dtn a time_point value
算术运算符(非成员函数) operator- tp - tp2 a duration value
关系操作符(非成员函数) operator== tp == tp2 a bool value
关系操作符(非成员函数) operator!= tp != tp2 a bool value
关系操作符(非成员函数) operator< tp < tp2 a bool value
关系操作符(非成员函数) operator> tp > tp2 a bool value
关系操作符(非成员函数) operator>= tp >= tp2 a bool value
关系操作符(非成员函数) operator<= tp <= tp2 a bool value

由于该时间点类经常和下面要介绍的时钟类一起使用，所以在此先不举例，在时钟类的示例代码中会涉及到时间点类的使用，到此为止只需要搞明白时间点类的提供的这几个函数的作用就可以了。

3.时钟Clock

chrono库中提供了获取当前的系统时间的时钟类，包含的时钟一共有三种：

  • system_clock：系统的时钟，系统的时钟可以修改，甚至可以网络对时，因此使用系统时间计算时间差可能不准。
  • steady_clock：是固定的时钟，相当于秒表。开始计时后，时间只会增长并且不能修改，适合用于记录程序耗时
  • high_resolution_clock：和时钟类 steady_clock 是等价的（是它的别名）。

在这些时钟类的内部有time_point、duration、Rep、Period等信息，基于这些信息来获取当前时间，以及实现time_t和time_point之间的相互转换。

时钟类成员类型 描述
rep 表示时钟周期次数的有符号算术类型
period 表示时钟计次周期的 std::ratio 类型
duration 时间间隔，可以表示负时长
time_point 表示在当前时钟里边记录的时间点

在使用chrono提供的时钟类的时候，不需要创建类对象，直接调用类的静态方法就可以得到想要的时间了。

3.1system_clock

具体来说，时钟类system_clock是一个系统范围的实时时钟。system_clock提供了对当前时间点time_point的访问，将得到时间点转换为time_t类型的时间对象，就可以基于这个时间对象获取到当前的时间信息了。

system_clock时钟类在底层源码中的定义如下：

struct system_clock { // wraps GetSystemTimePreciseAsFileTime/GetSystemTimeAsFileTime
    using rep                       = long long;
    using period                    = ratio<1, 10'000'000>; // 100 nanoseconds
    using duration                  = chrono::duration<rep, period>;
    using time_point                = chrono::time_point<system_clock>;
    static constexpr bool is_steady = false;

    _NODISCARD static time_point now() noexcept 
    { // get current time
        return time_point(duration(_Xtime_get_ticks()));
    }

    _NODISCARD static __time64_t to_time_t(const time_point& _Time) noexcept 
    { // convert to __time64_t
        return duration_cast<seconds>(_Time.time_since_epoch()).count();
    }

    _NODISCARD static time_point from_time_t(__time64_t _Tm) noexcept 
    { // convert from __time64_t
        return time_point{seconds{_Tm}};
    }
};

通过以上源码可以了解到在system_clock类中的一些细节信息：

  • rep：时钟周期次数是通过整形来记录的long long
  • period：一个时钟周期是100纳秒ratio<1, 10’000’000>
  • duration：时间间隔为rep*period纳秒chrono::duration<rep, period>
  • time_point：时间点通过系统时钟做了初始化chrono::time_point<system_clock>，里面记录了新纪元时间点

另外还可以看到system_clock类一共提供了三个静态成员函数：

// 返回表示当前时间的时间点。
static std::chrono::time_point<std::chrono::system_clock> now() noexcept;
// 将 time_point 时间点类型转换为 std::time_t 类型
static std::time_t to_time_t( const time_point& t ) noexcept;
// 将 std::time_t 类型转换为 time_point 时间点类型
static std::chrono::system_clock::time_point from_time_t( std::time_t t ) noexcept;

比如，我们要获取当前的系统时间，并且需要将其以能够识别的方式打印出来，示例代码如下：

#include <chrono>
#include <iostream>
using namespace std;
using namespace std::chrono;
int main()
{
    // 新纪元1970.1.1时间
    system_clock::time_point epoch;

    duration<int, ratio<60*60*24>> day(1);
    // 新纪元1970.1.1时间 + 1天
    system_clock::time_point ppt(day);

    using dday = duration<int, ratio<60 * 60 * 24>>;
    // 新纪元1970.1.1时间 + 10天
    time_point<system_clock, dday> t(dday(10));

    // 系统当前时间
    system_clock::time_point today = system_clock::now();
    
    // 转换为time_t时间类型
    time_t tm = system_clock::to_time_t(today);
    cout << "今天的日期是:    " << ctime(&tm);

    time_t tm1 = system_clock::to_time_t(today+day);
    cout << "明天的日期是:    " << ctime(&tm1);

    time_t tm2 = system_clock::to_time_t(epoch);
    cout << "新纪元时间:      " << ctime(&tm2);

    time_t tm3 = system_clock::to_time_t(ppt);
    cout << "新纪元时间+1天:  " << ctime(&tm3);

    time_t tm4 = system_clock::to_time_t(t);
    cout << "新纪元时间+10天: " << ctime(&tm4);
}

示例代码打印的结果为：

今天的日期是:    Thu Apr  8 11:09:49 2021
明天的日期是:    Fri Apr  9 11:09:49 2021
新纪元时间:      Thu Jan  1 08:00:00 1970
新纪元时间+1天:  Fri Jan  2 08:00:00 1970
新纪元时间+10天: Sun Jan 11 08:00:00 1970
3.2steady_clock

如果我们通过时钟不是为了获取当前的系统时间，而是进行程序耗时的时长，此时使用syetem_clock就不合适了，因为这个时间可以跟随系统的设置发生变化。在C++11中提供的时钟类steady_clock相当于秒表，只要启动就会进行时间的累加，并且不能被修改，非常适合于进行耗时的统计。

steady_clock时钟类在底层源码中的定义如下：

struct steady_clock { // wraps QueryPerformanceCounter
    using rep                       = long long;
    using period                    = nano;
    using duration                  = nanoseconds;
    using time_point                = chrono::time_point<steady_clock>;
    static constexpr bool is_steady = true;

    // get current time
    _NODISCARD static time_point now() noexcept 
    { 
        // doesn't change after system boot
        const long long _Freq = _Query_perf_frequency(); 
        const long long _Ctr  = _Query_perf_counter();
        static_assert(period::num == 1, "This assumes period::num == 1.");
        const long long _Whole = (_Ctr / _Freq) * period::den;
        const long long _Part  = (_Ctr % _Freq) * period::den / _Freq;
        return time_point(duration(_Whole + _Part));
    }
};

通过以上源码可以了解到在steady_clock类中的一些细节信息：

  • rep：时钟周期次数是通过整形来记录的long long
  • period：一个时钟周期是1纳秒nano
  • duration：时间间隔为1纳秒nanoseconds
  • time_point：时间点通过系统时钟做了初始化chrono::time_point<steady_clock>

另外，在这个类中也提供了一个静态的now()方法，用于得到当前的时间点，函数原型如下：

static std::chrono::time_point<std::chrono::steady_clock> now() noexcept;

假设要测试某一段程序的执行效率，可以计算它执行期间消耗的总时长，示例代码如下：

#include <chrono>
#include <iostream>
using namespace std;
using namespace std::chrono;
int main()
{
    // 获取开始时间点
    steady_clock::time_point start = steady_clock::now();
    // 执行业务流程
    cout << "print 1000 stars ...." << endl;
    for (int i = 0; i < 1000; ++i)
    {
        cout << "*";
    }
    cout << endl;
    // 获取结束时间点
    steady_clock::time_point last = steady_clock::now();
    // 计算差值
    auto dt = last - start;
    cout << "总共耗时: " << dt.count() << "纳秒" << endl;
}
3.3high_resolution_clock

high_resolution_clock提供的时钟精度比system_clock要高，它也是不可以修改的。在底层源码中，这个类其实是steady_clock类的别名。

using high_resolution_clock = steady_clock;

4.转换函数

4.1duration_cast
  • 在上面我们介绍过duration的类型转换，可以将一个低精度的单位类型转换为一个高精度的单位类型（例如，将分钟转换为秒，将秒转换为微秒），但是不能将一个高精度的单位类型转换为一个低精度的单位类型（例如，将微秒转换为秒，将秒转换为分钟等。因为这可能会造成数据的丢失，例如将42010毫秒转换为秒，结果是42，那么原本的10毫秒就丢失了）
  • 如果想要将高精度的单位类型转换为一个低精度的单位类型，那么可以使用duration_cast<>进行强制转换
  • 例如：
chrono::seconds sec(55);
 
//错误的，默认不能将秒转换为分钟
chrono::minutes m1 = sec;
 
//正确的，可以使用duration_cast，将秒转换为分钟
chrono::minutes m2 = chrono::duration_cast<chrono::minutes>(sec);
  • 将浮点数类型的duration转换为整数类型的duration也需要使用duration_cast<>。例如：
chrono::duration<double, std::ratio<60>> halfMin(0.5);
 
//错误，halfMin的tick为double类型，s1的tick默认为int类型
chrono::seconds s1 = halfMin;
 
//正确，使用duration_cast强制转换
chrono::seconds s2 = chrono::duration_cast<chrono::seconds>(halfMin);

#include <iostream>
#include <chrono>
using namespace std;
using namespace std::chrono;

void f()
{
    cout << "print 1000 stars ...." << endl;
    for (int i = 0; i < 1000; ++i)
    {
        cout << "*";
    }
    cout << endl;
}

int main()
{
    auto t1 = steady_clock::now();
    f();
    auto t2 = steady_clock::now();

    // 整数时长：时钟周期纳秒转毫秒，要求 duration_cast
    auto int_ms = duration_cast<chrono::milliseconds>(t2 - t1);

    // 小数时长：不要求 duration_cast
    duration<double, ratio<1, 1000>> fp_ms = t2 - t1;

    cout << "f() took " << fp_ms.count() << " ms, "
        << "or " << int_ms.count() << " whole milliseconds\n";
}

示例代码输出的结果：

print 1000 stars ....
**************************************
f() took 40.2547 ms, or 40 whole milliseconds
4.2time_point_cast

time_point_cast也是chrono库提供的一个模板函数，这个函数不属于time_point类。函数的作用是对时间点进行转换，因为不同的时间点对象内部的时钟周期Period，和周期次数的类型Rep可能也是不同的，一般情况下它们之间可以进行隐式类型转换，也可以通过该函数显示的进行转换，函数原型如下：

template <class ToDuration, class Clock, class Duration>
time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration> &t);

关于函数的使用，示例代码如下：

#include <chrono>
#include <iostream>
using namespace std;

using Clock = chrono::high_resolution_clock;
using Ms = chrono::milliseconds;
using Sec = chrono::seconds;
template<class Duration>
using TimePoint = chrono::time_point<Clock, Duration>;

void print_ms(const TimePoint<Ms>& time_point)
{
    std::cout << time_point.time_since_epoch().count() << " ms\n";
}

int main()
{
    TimePoint<Sec> time_point_sec(Sec(6));
    // 无精度损失, 可以进行隐式类型转换
    TimePoint<Ms> time_point_ms(time_point_sec);
    print_ms(time_point_ms);    // 6000 ms

    time_point_ms = TimePoint<Ms>(Ms(6789));
    // error，会损失精度，不允许进行隐式的类型转换
    TimePoint<Sec> sec(time_point_ms);

    // 显示类型转换,会损失精度。6789 truncated to 6000
    time_point_sec = std::chrono::time_point_cast<Sec>(time_point_ms);
    print_ms(time_point_sec); // 6000 ms
}

注意事项：关于时间点的转换如果没有没有精度的损失可以直接进行隐式类型转换，如果会损失精度只能通过显示类型转换，也就是调用time_point_cast函数来完成该操作。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1291600.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

UDP协议实现群聊

UDP协议实现群聊

服务端 package ydd;import java.io.*; import java.net.*; import java.util.ArrayList; public class A2{public static ServerSocket server_socket;public static ArrayList<Socket> socketListnew ArrayList<Socket>(); public static void main(String []a…
阅读更多...
16个UI设计小规则，但是却能产生巨大影响

16个UI设计小规则，但是却能产生巨大影响

我的新书《Android App开发入门与实战》已于2020年8月由人民邮电出版社出版&#xff0c;欢迎购买。点击进入详情 文章目录 1.使用空间对相关元素进行分组2.保持一致3.确保外观相似的元素功能相似4.创建清晰的视觉层次5.删除不必要的样式6.有目的地使用颜色7.确保界面元素的对比…
阅读更多...
基于OpenCV+CNN+IOT+微信小程序智能果实采摘指导系统——深度学习算法应用(含pytho、JS工程源码)+数据集+模型（三）

基于OpenCV+CNN+IOT+微信小程序智能果实采摘指导系统——深度学习算法应用(含pytho、JS工程源码)+数据集+模型（三）

目录 前言总体设计系统整体结构图系统流程图 运行环境Python环境TensorFlow 环境Jupyter Notebook环境Pycharm 环境微信开发者工具OneNET云平台 模块实现1. 数据预处理1&#xff09;爬取功能2&#xff09;下载功能 2. 创建模型并编译1&#xff09;定义模型结构2&#xff09;优化…
阅读更多...
RT-DETR手把手教程：NEU-DET钢材表面缺陷检测任务 | 不同网络位置加入EMA注意力进行魔改

RT-DETR手把手教程：NEU-DET钢材表面缺陷检测任务 | 不同网络位置加入EMA注意力进行魔改

&#x1f4a1;&#x1f4a1;&#x1f4a1;本文独家改进&#xff1a;本文首先复现了将EMA引入到RT-DETR中&#xff0c;并跟不同模块进行结合创新&#xff1b;1&#xff09;多种Rep C3结合&#xff1b;2&#xff09;直接作为注意力机制放在网络不同位置&#xff1b; NEU-DET钢材…
阅读更多...
rename--一些例子与问题

rename--一些例子与问题

指令 A 和指令 B之间存在先写后读(RAW)的相关性 指令 B 的源寄存器 r0 来自于指令 A 产生的结果因此在进行寄存器重命名的时候&#xff0c;指令 B 的 r0 对应的物理寄存器应该直接来自于指令A所对应的P30,而不应该来自于从RAT读取的值。指令A,B,D之间存在先写后写(WAW)的相关性…
阅读更多...
指针（二）

指针（二）

这里写目录标题 字符指针字符指针与常量字符串的区别&#xff1a; 指针数组数组指针两者的区别&#xff1a;&数组名 &#xff0c;sizeof(arr)数组指针的使用数组参数&#xff0c;指针参数一维数组传参整型数组&#xff1a;整型指针数组&#xff1a; 一级指针传参二级指针传…
阅读更多...
openai 1.3.x 版本 openai.APITimeoutError: Request timed out. 解决

openai 1.3.x 版本 openai.APITimeoutError: Request timed out. 解决

问题描述 openai 1.3.x 版本 请求出现 Request timed out File "E:\Python\Python312\Lib\site-packages\openai\_base_client.py", line 920, in _request return self._retry_request( ^^^^^^^^^^^^^^^^^^^^ File "E:\Python\Python312\L…
阅读更多...
数据结构与算法编程题48

数据结构与算法编程题48

有向图的邻接表 #include <iostream> using namespace std;#define MVnum 100 typedef string VertexType;typedef struct ArcNode {int adjvex;struct ArcNode* nextarc;int weight; }ArcNode;typedef struct VNode {VertexType data;struct ArcNode* firstarc; }VNode,…
阅读更多...
NAS外网访问方案

NAS外网访问方案

基础流程 路由器开启端口映射&#xff08;如果有猫则要配置猫为转发模式&#xff0c;由路由器直接拨号即可使用第三方程序让内网ip发布到公网上&#xff08;如果有云服务器&#xff09;需要开启防火墙端口 好用的第三方程序 FRP穿透 优点&#xff1a;开源免费&#xff0c;速…
阅读更多...
基于ssm学院党员管理系统论文

基于ssm学院党员管理系统论文

摘 要 互联网发展至今&#xff0c;无论是其理论还是技术都已经成熟&#xff0c;而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播&#xff0c;搭配信息管理工具可以很好地为人们提供服务。针对鄂尔多斯应用技术学院党员信息管理混乱&#xff0c;出错率高&#x…
阅读更多...
金蝶云星空业务对象列表显示动态列

金蝶云星空业务对象列表显示动态列

文章目录 金蝶云星空业务对象列表显示动态列需求设计开发实现列表插件字段标题数据绑定前事件数据绑定列表插件注册测试 金蝶云星空业务对象列表显示动态列 需求设计 《产品序列号档案》的序列号、适用组织分别关联《序列号主档》的序列号字段&#xff0c;的适用组织表的组织…
阅读更多...
Java简易版 TCP协议一对一聊天

Java简易版 TCP协议一对一聊天

客户端 package 二十一章;import java.io.*; import java.net.Socket; import java.util.Date; import javax.swing.*;public class Server {private JFrame jf;private JButton jBsend;private JTextArea jTAcontent;private JTextField jText;private JLabel JLcontent;priv…
阅读更多...
1.pipenv创建pyqt5虚拟环境

1.pipenv创建pyqt5虚拟环境

pipenv创建pyqt5虚拟环境 一、安装pipenv ​ cmd输入指令&#xff1a; pip install pipenv二、安装虚拟环境 cmd进入我要创建环境的目录下 我使用以下命令在当前目录下创建虚拟环境&#xff1a; pipenv --python 3.8创建一个基于Python 3.8的虚拟环境&#xff0c;并生成一个…
阅读更多...
深度探索Linux操作系统 —— 构建内核

深度探索Linux操作系统 —— 构建内核

系列文章目录 深度探索Linux操作系统 —— 编译过程分析 深度探索Linux操作系统 —— 构建工具链 深度探索Linux操作系统 —— 构建内核 文章目录 系列文章目录前言一、内核映像的组成 前言 内核的构建系统 kbuild 基于GNU Make&#xff0c;是一套非常复杂的系统。 对于编译内核…
阅读更多...
【神化世界】asp网页500内部服务器错误的解决方法

【神化世界】asp网页500内部服务器错误的解决方法

问题解决方案记录 一、问题 在asp网页调试的时候&#xff0c;不小心改错了&#xff0c;好好的页面突然出现如下错误信息了&#xff1a; 二、解决方法 终于找到了问题所在&#xff0c;是sql语句出错造成的&#xff0c;特别记录一下。 正确的写法 sql"select * from mem…
阅读更多...
好用的远程访问软件有哪些？

好用的远程访问软件有哪些？

借助远程访问软件可以对不在身边的电脑进行远程控制或访问&#xff0c;这对于需要远程办公的人来说十分的方便&#xff0c;通过这些软件可以使团队协作和沟通不再受地域限制。市面上的远程访问软件有很多&#xff0c;有哪些好用的远程访问软件呢&#xff1f;这里&#xff0c;本…
阅读更多...
【顶级神刊】IEEE旗下TOP，CCF-A，投稿5次也要一试再试，升职法宝，这本期刊逆天了！

【顶级神刊】IEEE旗下TOP，CCF-A，投稿5次也要一试再试，升职法宝，这本期刊逆天了！

计算机类 • 好刊解读 今天小编带来IEEE旗下计算机领域顶级神刊&#xff0c;CCF-A类推荐的期刊解读&#xff0c;众多作者投稿5次也要一试再试&#xff0c;究竟这本期刊如何&#xff1f;如您有投稿需求&#xff0c;可作为重点关注&#xff01;后文有相关领域真实发表案例&#…
阅读更多...
网络安全攻击预警/态势预测算法汇总

网络安全攻击预警/态势预测算法汇总

总结&#xff1a; 网络安全攻击预警/态势预测算法众多&#xff0c;主要包括&#xff1a; 基于统计学的算法&#xff1a;协方差矩阵、马尔可夫模型等&#xff1b; 基于机器学习的算法&#xff1a;贝叶斯网络、聚类算法、支持向量机SVM、遗传算法、层次分析法AHP、决策树等&am…
阅读更多...
Talk | UCSB博士生欧阳思琦: 利用词级别对比学习实现低资源下的语音翻译

Talk | UCSB博士生欧阳思琦: 利用词级别对比学习实现低资源下的语音翻译

本期为TechBeat人工智能社区第553期线上Talk。 北京时间12月6日(周三)20:00&#xff0c;加州大学圣塔芭芭拉分校博士生—欧阳思琦的Talk将准时在TechBeat人工智能社区开播&#xff01; 他与大家分享的主题是: “利用词级别对比学习实现低资源下的语音翻译”&#xff0c;介绍了他…
阅读更多...
扔掉sql语句，用 QxOrm 让你的数据库操作从来没有这么简单过！

扔掉sql语句，用 QxOrm 让你的数据库操作从来没有这么简单过！

ORM简介&#xff1a; ORM 全称是 Object Relational Mapping&#xff08;对象关系映射&#xff09;&#xff0c;是一种程序设计技术&#xff0c;用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说&#xff0c;它其实是创建了一个可在编程语言里使用的“虚拟…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023