QT基础八、与时间相关的UI控件

#include <QTime>

// 创建一个无效的 QTime 对象
QTime time;

// 创建一个指定时间的 QTime 对象 (小时, 分钟, 秒, 毫秒)
QTime time1(14, 30, 0);  // 14:30:00
QTime time2(14, 30, 0, 500);  // 14:30:00.500

//由字符串转化
QTime time3 = QTime::fromString("12:55:32");

QString str = "10点10分";
QTime time4 = QTime::fromString(str, "hh点mm分");    //10:10:00.000

2. 获取当前时间

QTime currentTime = QTime::currentTime();
qDebug() << "当前时间:" << currentTime.toString("hh:mm:ss.zzz");

3. 设置时间

QTime time;
time.setHMS(10, 15, 30);  // 设置时间为 10:15:30
qDebug() << "Set Time:" << time.toString("hh:mm:ss");

4. 时间格式化

QTime time(14, 30, 45, 123);
qDebug() << time.toString("hh:mm:ss.zzz");  // 输出: 14:30:45.123
qDebug() << time.toString("hh:mm");  // 输出: 14:30

QTime time2 = QTime::currentTime();
qDebug() << time2.toString("h:m:s.zzz");

常用的格式符：

h：小时（无前导零）
hh：小时（有前导零）
m：分钟（无前导零）
mm：分钟（有前导零）
s：秒（无前导零）
ss：秒（有前导零）
z：毫秒（无前导零）
zzz：毫秒（有前导零）

5. 时间加减操作

QTime time(14, 30, 0);

// 加上 90 秒
QTime newTime = time.addSecs(90);
qDebug() << "加了90秒后:" << newTime.toString("hh:mm:ss");

// 减去 5000 毫秒
QTime newTime2 = time.addMSecs(-5000);
qDebug() << "减去5000毫秒后:" << newTime2.toString("hh:mm:ss.zzz");

6. 时间比较

可以使用 operator<, operator>, operator== 等运算符来比较两个 QTime 对象：

QTime time1(14, 30, 0);
QTime time2(15, 0, 0);

if (time1 < time2) {
    qDebug() << "time1 < time2";
} else if (time1 > time2) {
    qDebug() << "time1 > time2";
} else {
    qDebug() << "time1 == same";
}

7. 计算时间间隔

QTime time1(14, 30, 0);
QTime time2(15, 0, 0);

//相当于 time2 - time1
int secs = time1.secsTo(time2);  // 返回两个时间之间的秒数
qDebug() << "time1 和 time2 之间的秒数:" << secs;

int msecs = time1.msecsTo(time2);  // 返回两个时间之间的毫秒数
qDebug() << "time1 和 time2 之间的毫秒数:" << msecs;

8. 判断时间是否有效

QTime time(25, 0, 0);  // 无效时间，因为小时数超过了 23
if (!time.isValid()) {
    qDebug() << "这是一个无效时间!";
}

9. 使用 `QElapsedTimer` 测量时间间隔

#include <QElapsedTimer>

QElapsedTimer timer;
timer.start();

// 执行一些操作
QThread::sleep(2);

qint64 elapsed = timer.elapsed();  // 返回经过的毫秒数
qDebug() << "经过了:" << elapsed << "毫秒";

二、日期类：QDate

QDate 是 Qt 框架中的一个类，用于处理日期相关的操作。它可以表示年、月、日，并提供了许多有用的功能，例如日期的设置、比较、加减操作等。

1. 创建 `QDate` 对象

#include <QDate>

// 创建一个无效的 QDate 对象
QDate date;

// 创建一个指定日期的 QDate 对象 (年, 月, 日)
QDate date1(2023, 10, 5);  // 2023年10月5日

2. 获取当前日期

QDate currentDate = QDate::currentDate();
qDebug() << "当前日期是:" << currentDate.toString("yyyy-MM-dd");

3. 设置日期

QDate date;
date.setDate(2023, 10, 5);  // 设置日期为 2023年10月5日
qDebug() << "设置后的日期是:" << date.toString("yyyy-MM-dd");

4. 日期格式化

QDate date(2023, 10, 5);
qDebug() << "格式化后的日期是:" << date.toString("yyyy-MM-dd");  // 输出: 2023-10-05
qDebug() << "简短日期格式是:" << date.toString("dd/MM/yyyy");  // 输出: 05/10/2023

常用的格式符：

d：日（无前导零）
dd：日（有前导零）
M：月（无前导零）
MM：月（有前导零）
yy：年（两位数）
yyyy：年（四位数）

5. 日期加减操作

QDate date(2023, 10, 5);

// 加上 10 天
QDate newDate = date.addDays(10);
qDebug() << "加上10天后的日期是:" << newDate.toString("yyyy-MM-dd");

// 减去 1 个月
QDate newDate2 = date.addMonths(-1);
qDebug() << "减去1个月后的日期是:" << newDate2.toString("yyyy-MM-dd");

// 加上 2 年
QDate newDate3 = date.addYears(2);
qDebug() << "加上2年后的日期是:" << newDate3.toString("yyyy-MM-dd");

6. 日期比较

QDate date1(2023, 10, 5);
QDate date2(2023, 10, 10);

if (date1 < date2) {
    qDebug() << "date1比date2早";
} else if (date1 > date2) {
    qDebug() << "date1比date2晚";
} else {
    qDebug() << "date1和date2是同一天";
}

7. 计算日期间隔

QDate date1(2023, 10, 5);
QDate date2(2023, 10, 10);

int days = date1.daysTo(date2);  // 返回两个日期之间的天数
qDebug() << "date1和date2之间相差的天数是:" << days;

8. 判断日期是否有效

QDate date(2023, 2, 30);  // 无效日期，因为2月没有30天
if (!date.isValid()) {
    qDebug() << "这是一个无效的日期!";
}

9. 获取日期信息

QDate date(2023, 10, 5);
qDebug() << "年份是:" << date.year();  // 输出: 2023
qDebug() << "月份是:" << date.month();  // 输出: 10
qDebug() << "日期是:" << date.day();  // 输出: 5

10. 获取星期几

QDate date(2023, 10, 5);
int dayOfWeek = date.dayOfWeek();  // 返回 1-7，1 表示星期一，7 表示星期日
qDebug() << "这一天是星期" << dayOfWeek;  // 输出: 4 (星期四)

11. 获取一年中的第几天

QDate date(2023, 10, 5);
int dayOfYear = date.dayOfYear();
qDebug() << "这一天是一年中的第" << dayOfYear << "天";  // 输出: 278

12. 获取月份的天数

QDate date(2023, 10, 5);
int daysInMonth = date.daysInMonth();
qDebug() << "这个月有" << daysInMonth << "天";  // 输出: 31

13. 获取一年的天数

QDate date(2023, 10, 5);
int daysInYear = date.daysInYear();
qDebug() << "这一年有" << daysInYear << "天";  // 输出: 365 (2023年不是闰年)

14. 判断是否为闰年

bool isLeapYear = QDate::isLeapYear(2024);
qDebug() << "2024年是闰年吗?" << isLeapYear;  // 输出: true

三、日期时间类：QDateTime

QDateTime 是 Qt 框架中的一个类，用于处理日期和时间的组合。它结合了 QDate 和 QTime 的功能，可以表示某个特定的日期和时间，并提供了许多有用的操作，例如时间戳、时间加减、格式化等。

1. 创建 `QDateTime` 对象

#include <QDateTime>

// 创建一个无效的 QDateTime 对象
QDateTime dateTime;

// 创建一个指定日期和时间的 QDateTime 对象 (年, 月, 日, 时, 分, 秒)
QDateTime dateTime1(QDate(2023, 10, 5), QTime(14, 30, 0));  
// 2023年10月5日 14:30:00

2. 获取当前日期和时间

QDateTime currentDateTime = QDateTime::currentDateTime();
qDebug() << "当前日期和时间是:" << currentDateTime.toString("yyyy-MM-dd hh:mm:ss");

3. 设置日期和时间

QDateTime dateTime;
dateTime.setDate(QDate(2023, 10, 5));  // 设置日期为 2023年10月5日
dateTime.setTime(QTime(14, 30, 0));    // 设置时间为 14:30:00
qDebug() << "设置后的日期和时间是:" << dateTime.toString("yyyy-MM-dd hh:mm:ss");

4. 日期和时间格式化

QDateTime dateTime(QDate(2023, 10, 5), QTime(14, 30, 45));
qDebug() << "格式化后的日期和时间是:" << dateTime.toString("yyyy-MM-dd hh:mm:ss.zzz");  
// 输出: 2023-10-05 14:30:45.000

qDebug() << "简短日期和时间格式是:" << dateTime.toString("dd/MM/yyyy hh:mm");  
// 输出: 05/10/2023 14:30

常用的格式符：

d：日（无前导零）
dd：日（有前导零）
M：月（无前导零）
MM：月（有前导零）
yy：年（两位数）
yyyy：年（四位数）
h：小时（无前导零）
hh：小时（有前导零）
m：分钟（无前导零）
mm：分钟（有前导零）
s：秒（无前导零）
ss：秒（有前导零）
z：毫秒（无前导零）
zzz：毫秒（有前导零）

5. 时间加减操作

QDateTime dateTime(QDate(2023, 10, 5), QTime(14, 30, 0));

// 加上 10 天
QDateTime newDateTime = dateTime.addDays(10);
qDebug() << "加上10天后的日期和时间是:" << newDateTime.toString("yyyy-MM-dd hh:mm:ss");

// 减去 1 个月
QDateTime newDateTime2 = dateTime.addMonths(-1);
qDebug() << "减去1个月后的日期和时间是:" << newDateTime2.toString("yyyy-MM-dd hh:mm:ss");

// 加上 90 秒
QDateTime newDateTime3 = dateTime.addSecs(90);
qDebug() << "加上90秒后的日期和时间是:" << newDateTime3.toString("yyyy-MM-dd hh:mm:ss");

// 减去 5000 毫秒
QDateTime newDateTime4 = dateTime.addMSecs(-5000);
qDebug() << "减去5000毫秒后的日期和时间是:" << newDateTime4.toString("yyyy-MM-dd hh:mm:ss.zzz");

6. 时间比较

QDateTime dateTime1(QDate(2023, 10, 5), QTime(14, 30, 0));
QDateTime dateTime2(QDate(2023, 10, 5), QTime(15, 0, 0));

if (dateTime1 < dateTime2) {
    qDebug() << "dateTime1比dateTime2早";
} else if (dateTime1 > dateTime2) {
    qDebug() << "dateTime1比dateTime2晚";
} else {
    qDebug() << "dateTime1和dateTime2是同一时刻";
}

7. 计算时间间隔

QDateTime dateTime1(QDate(2023, 10, 5), QTime(14, 30, 0));
QDateTime dateTime2(QDate(2023, 10, 5), QTime(15, 0, 0));

int secs = dateTime1.secsTo(dateTime2);  // 返回两个时间之间的秒数
qDebug() << "dateTime1和dateTime2之间相差的秒数是:" << secs;

qint64 msecs = dateTime1.msecsTo(dateTime2);  // 返回两个时间之间的毫秒数
qDebug() << "dateTime1和dateTime2之间相差的毫秒数是:" << msecs;

8. 判断日期和时间是否有效

QDateTime dateTime(QDate(2023, 2, 30), QTime(14, 30, 0));  
// 无效日期，因为2月没有30天

if (!dateTime.isValid()) {
    qDebug() << "这是一个无效的日期和时间!";
}

9. 获取时间戳

QDateTime dateTime(QDate(2023, 10, 5), QTime(14, 30, 0));
qint64 secsSinceEpoch = dateTime.toSecsSinceEpoch();
qDebug() << "自1970年以来的秒数是:" << secsSinceEpoch;

qint64 msecsSinceEpoch = dateTime.toMSecsSinceEpoch();
qDebug() << "自1970年以来的毫秒数是:" << msecsSinceEpoch;

10. 从时间戳创建 `QDateTime`

qint64 secsSinceEpoch = 1696485000;  // 假设这是某个时间戳
QDateTime dateTime = QDateTime::fromSecsSinceEpoch(secsSinceEpoch);
qDebug() << "从时间戳转换的日期和时间是:" << dateTime.toString("yyyy-MM-dd hh:mm:ss");

qint64 msecsSinceEpoch = 1696485000000;  // 假设这是某个时间戳
QDateTime dateTime2 = QDateTime::fromMSecsSinceEpoch(msecsSinceEpoch);
qDebug() << "从毫秒时间戳转换的日期和时间是:" << dateTime2.toString("yyyy-MM-dd hh:mm:ss.zzz");

11. 转换时区

QDateTime dateTime(QDate(2023, 10, 5), QTime(14, 30, 0), QTimeZone::systemTimeZone());

// 转换为 UTC 时间
QDateTime utcDateTime = dateTime.toTimeZone(QTimeZone::utc());
qDebug() << "UTC时间是:" << utcDateTime.toString("yyyy-MM-dd hh:mm:ss");

// 转换为其他时区，例如东京时间
QDateTime tokyoDateTime = dateTime.toTimeZone(QTimeZone("Asia/Tokyo"));
qDebug() << "东京时间是:" << tokyoDateTime.toString("yyyy-MM-dd hh:mm:ss");

12. 获取日期和时间信息

QDateTime dateTime(QDate(2023, 10, 5), QTime(14, 30, 0));
QDate date = dateTime.date();
QTime time = dateTime.time();

qDebug() << "日期是:" << date.toString("yyyy-MM-dd");
qDebug() << "时间是:" << time.toString("hh:mm:ss");

四、时间、日期编辑控件：QDateEdit、QTimeEdit、QDateTimeEdit

在 Qt 中，QDateTimeEdit、QDateEdit 和 QTimeEdit 是用于用户输入和编辑日期和时间的控件。它们分别用于处理日期和时间的不同组合，并且都继承自 QAbstractSpinBox，因此它们的行为类似于其他基于旋钮的控件（如 QSpinBox）。

编程实战，创建一个如下的界面：

1、创建时间编辑器

修改spinBox的后缀

将这些与时间相关的组件放入一个组，并水平布局

给这些组件改个名字

槽函数代码：

// 当按钮被点击时，将所有时间、日期相关的控件设置为当前的系统时间和日期
void Dialog::on_pushButton_clicked()
{
    // 设置开始时间编辑器为当前时间
    ui->timeEditStart->setTime(QTime::currentTime());
    // 设置结束时间编辑器为当前时间
    ui->timeEditEnd->setTime(QTime::currentTime());
}

// 当spinBoxTime的值发生变化时，根据变化的小时数调整结束时间
void Dialog::on_spinBoxTime_valueChanged(int arg1)
{
    // 获取开始时间，并加上spinBoxTime中设置的小时数（转换为秒）
    QTime time = ui->timeEditStart->time().addSecs(arg1 * 3600);
    // 将计算后的时间设置到结束时间编辑器
    ui->timeEditEnd->setTime(time);
}

2、创建日期编辑器

跟创建时间编辑器的步骤类似，节约时间，直接给你们看结果（记得改名字）

槽函数代码：

// 当按钮被点击时，将所有时间、日期相关的控件设置为当前的系统时间和日期
void Dialog::on_pushButton_clicked()
{
    // 设置开始时间编辑器为当前时间
    ui->timeEditStart->setTime(QTime::currentTime());
    // 设置结束时间编辑器为当前时间
    ui->timeEditEnd->setTime(QTime::currentTime());
    
    // 设置开始日期编辑器为当前日期
    ui->dateEditStart->setDate(QDate::currentDate());
    // 设置结束日期编辑器为当前日期
    ui->dateEditEnd->setDate(QDate::currentDate());
}

// 当spinBoxTime的值发生变化时，根据变化的小时数调整结束时间
void Dialog::on_spinBoxTime_valueChanged(int arg1)
{
    // 获取开始时间，并加上spinBoxTime中设置的小时数（转换为秒）
    QTime time = ui->timeEditStart->time().addSecs(arg1 * 3600);
    // 将计算后的时间设置到结束时间编辑器
    ui->timeEditEnd->setTime(time);
}

// 当spinBoxDate的值发生变化时，根据变化的天数调整结束日期
void Dialog::on_spinBoxDate_valueChanged(int arg1)
{
    // 获取开始日期，并加上spinBoxDate中设置的天数
    QDate date = ui->dateEditStart->date().addDays(arg1);
    // 将计算后的日期设置到结束日期编辑器
    ui->dateEditEnd->setDate(date);
}

3、日期时间编辑器

创建一个如下的界面

槽函数代码：

// 当按钮被点击时，将所有时间、日期相关的控件设置为当前的系统时间和日期
void Dialog::on_pushButton_clicked()
{
    // 设置开始时间编辑器为当前时间
    ui->timeEditStart->setTime(QTime::currentTime());
    // 设置结束时间编辑器为当前时间
    ui->timeEditEnd->setTime(QTime::currentTime());
    
    // 设置开始日期编辑器为当前日期
    ui->dateEditStart->setDate(QDate::currentDate());
    // 设置结束日期编辑器为当前日期
    ui->dateEditEnd->setDate(QDate::currentDate());
    
    // 设置开始日期时间编辑器的日期为当前日期
    ui->dateTimeEditStart->setDate(QDate::currentDate());
    // 设置开始日期时间编辑器的时间为当前时间
    ui->dateTimeEditStart->setTime(QTime::currentTime());
    
    // 设置结束日期时间编辑器的日期为当前日期
    ui->dateTimeEditEnd->setDate(QDate::currentDate());
    // 设置结束日期时间编辑器的时间为当前时间
    ui->dateTimeEditEnd->setTime(QTime::currentTime());
}

// 当spinBoxTime的值发生变化时，根据变化的小时数调整结束时间
void Dialog::on_spinBoxTime_valueChanged(int arg1)
{
    // 获取开始时间，并加上spinBoxTime中设置的小时数（转换为秒）
    QTime time = ui->timeEditStart->time().addSecs(arg1 * 3600);
    // 将计算后的时间设置到结束时间编辑器
    ui->timeEditEnd->setTime(time);
}

// 当spinBoxDate的值发生变化时，根据变化的天数调整结束日期
void Dialog::on_spinBoxDate_valueChanged(int arg1)
{
    // 获取开始日期，并加上spinBoxDate中设置的天数
    QDate date = ui->dateEditStart->date().addDays(arg1);
    // 将计算后的日期设置到结束日期编辑器
    ui->dateEditEnd->setDate(date);
}

// 当spinBoxDays的值发生变化时，根据变化的天数调整结束日期时间的日期部分
void Dialog::on_spinBoxDays_valueChanged(int arg1)
{
    // 获取开始日期时间的日期部分，并加上spinBoxDays中设置的天数
    QDate date = ui->dateTimeEditStart->date().addDays(arg1);
    // 将计算后的日期设置到结束日期时间编辑器的日期部分
    ui->dateTimeEditEnd->setDate(date);
}

4、运行结果

五、日历控件：QCalendarWidget

QCalendarWidget 是 Qt 框架中的一个 GUI 组件，用于显示和选择日期。它提供了一个直观的月历界面，用户可以通过点击选择日期，并支持多种自定义功能，例如设置日期范围、高亮特定日期、更改外观样式等。

1.、基本功能

QCalendarWidget 提供以下核心功能：

显示日历 ：以月为单位显示日期，默认显示当前月份。
日期选择 ：用户可以通过鼠标点击选择某个日期。
导航功能 ：允许用户切换月份或年份。
日期范围限制 ：可以设置可选日期的最小值和最大值。
高亮特定日期 ：支持标记某些日期（如节假日或重要事件）。
国际化支持 ：支持不同语言和地区的时间格式。

2、先做出如下的页面

3、常用信号

QCalendarWidget 提供了几个常用的信号，用于响应用户的操作。例如：

selectionChanged() ：当用户选择的日期发生变化时触发。
currentPageChanged(int year, int month) ：当用户切换月份或年份时触发。

4、生成槽函数

5、槽函数代码

void Dialog::on_calendarWidget_selectionChanged()
{
    auto date =ui->calendarWidget->selectedDate();
    QString str = date.toString("yyyy年M月d日");
    ui->dateEdit->setDate(date);
    ui->lineEdit->setText(str);
}

6、运行结果

六、定时器：Timer

QTimer 是 Qt 框架中的一个类，用于在应用程序中实现定时器功能。它允许开发者以指定的时间间隔执行某些操作，例如定期更新界面、处理后台任务或触发事件。

1、创建一个如下的界面

更改一下进度条的值为0

2、什么是TimerType

类型：Qt::TimerType
描述：定时器的精度类型，决定定时器的触发精度。
可选值 ：
- Qt::VeryCoarseTimer：非常低精度的定时器，通常以秒为单位触发。
- Qt::CoarseTimer：低精度定时器，允许操作系统优化触发时间。
- Qt::PreciseTimer：高精度定时器，尽可能精确地触发。毫秒级
默认值 ：Qt::CoarseTimer。

timer->setTimerType(Qt::PreciseTimer); // 设置为高精度定时器

3、dialog.h的代码

#ifndef DIALOG_H
#define DIALOG_H

#include <QDialog>  // 包含 QDialog 类，用于创建对话框窗口
#include <QTimer>   // 包含 QTimer 类，用于定时器功能

QT_BEGIN_NAMESPACE
namespace Ui { class Dialog; }  // 声明 UI 命名空间，用于管理 UI 文件生成的类
QT_END_NAMESPACE

class Dialog : public QDialog
{
    Q_OBJECT  // 宏定义，允许使用 Qt 的信号与槽机制

public:
    Dialog(QWidget *parent = nullptr);  // 构造函数，初始化对话框
    ~Dialog();                          // 析构函数，释放资源

private slots:
    void on_timer_timeout();            // 定时器超时时触发的槽函数
    void on_pushButtonStart_clicked(); // 开始按钮点击时触发的槽函数
    void on_pushButtonStop_clicked();  // 停止按钮点击时触发的槽函数

private:
    void initUi();                      // 初始化界面和组件
    Ui::Dialog *ui;                     // 指向由 Qt Designer 生成的 UI 对象
    QTimer* m_timer;                    // 定时器对象，用于计时功能
    long timeGo;                        // 记录已用时间（秒）
};

#endif // DIALOG_H

4、dialog.cpp的代码

#include "dialog.h"      
#include "ui_dialog.h"   

// 构造函数，初始化对话框
Dialog::Dialog(QWidget *parent)
    : QDialog(parent)    
    , ui(new Ui::Dialog) 
{
    ui->setupUi(this);   // 设置 UI 界面
    timeGo = 0;          // 初始化计时器时间为 0 秒
    ui->label->setText("已用时：0秒"); // 设置标签初始文本
    initUi();            // 初始化界面和组件
}

Dialog::~Dialog()
{
    delete ui;           
}

// 定时器超时时触发的槽函数
void Dialog::on_timer_timeout()
{
    timeGo++;            // 每次超时增加 1 秒
    QString str = "已用时："; // 构造显示字符串
    str.append(QString::number(timeGo) + "秒"); // 将秒数转换为字符串并拼接
    ui->label->setText(str); // 更新标签显示内容

    int value = ui->progressBar->value() + 1; // 获取进度条当前值并加 1
    if (value > 100) value = 0;               // 如果超过 100，则重置为 0
    ui->progressBar->setValue(value);         // 更新进度条值
}

// 初始化界面和组件
void Dialog::initUi()
{
    m_timer = new QTimer(this);              // 创建定时器对象
    m_timer->setTimerType(Qt::PreciseTimer); // 设置定时器类型为高精度
    m_timer->setInterval(1000);              // 设置定时器间隔为 1000 毫秒（1 秒）
    connect(m_timer, SIGNAL(timeout()),      // 连接定时器的 timeout 信号
            this, SLOT(on_timer_timeout())); // 到槽函数 on_timer_timeout
}

// 开始按钮点击时触发的槽函数
void Dialog::on_pushButtonStart_clicked()
{
    m_timer->start(); // 启动定时器
}

// 停止按钮点击时触发的槽函数
void Dialog::on_pushButtonStop_clicked()
{
    m_timer->stop();  // 停止定时器
}