Qt基础: 数据类型

1. 基础类型

Qt是一个C++ 框架, 因此C++中所有的语法和数据类型在Qt中都是被支持的, 但是Qt中也定义了一些属于自己的数据类型, 下边给大家介绍一下这些基础的数类型。

QT基本数据类型定义在#include < QtGlobal> 中，QT基本数据类型有：

类型名称	注释	备注
qint8	signed char	有符号8位数据
qint16	signed short	16位数据类型
qint32	signed short	32位有符号数据类型
qint64	long long int 或(__int64)	64位有符号数据类型，Windows中定义为__int64
qintptr	qint32 或 qint64	指针类型 32位为qint32、64位为qint64
qlonglong	long long int 或(__int64)	Windows中定义为__int64
qptrdiff	qint32 或 qint64	32位系统为qint32、64位系统为qint64
qreal	double 或 float	除非配置了-qreal float选项，否则默认为double
quint8	unsigned char	无符号8位数据类型
quint16	unsigned short	无符号16位数据类型
quint32	unsigned int	无符号32位数据类型
quint64	unsigned long long int 或 (unsigned __int64)	无符号64比特数据类型，Windows中定义为unsigned __int64
quintptr	quint32 或 quint64	32位系统为quint32、64位系统为quint64
qulonglong	unsigned long long int 或 (unsigned __int64)	Windows中定义为__int64
uchar	unsigned char	无符号字符类型
uint	unsigned int	无符号整型
ulong	unsigned long	无符号长整型
ushort	unsigned short	无符号短整型

编程过程中一般不用Qt中的整形或者浮点型，它们基本上只是对标准的 C++ 类型（如 int, float, double）进行了封装或别名

2. 字符串类型

语言类型	字符串类型
C	char*
C++	std::string, char*
Qt	QByteArray, QString 等

2.1 QByteArray

QByteArray类用于处理字节数组。可以将QByteArray 视为 char* 的一个增强和封装版本。

QByteArray通常用于处理二进制数据或原始字节流

QByteArray提供了一系列的方法和操作符，用于操作字节数组，如 append(), prepend(), remove(), mid(), startsWith(), endsWith() 等。这些功能使得处理字节数据变得简单而直观。

QByteArray 可以隐式地转换为const char*，也可以方便地转换为QString或其他 Qt 数据类型。

在 Qt 应用程序中，当需要处理字节数据时，通常首选QByteArray而不是直接使用 char*。

构造函数

// 构造空对象, 里边没有数据
QByteArray::QByteArray();

// 将data中的size个字符进行构造, 得到一个字节数组对象
// 如果 size==-1 函数内部自动计算字符串长度, 计算方式为: strlen(data)
QByteArray::QByteArray(const char *data, int size = -1);

// 构造一个长度为size个字节, 并且每个字节值都为ch的字节数组
QByteArray::QByteArray(int size, char ch);

尾部追加数据

QByteArray &QByteArray::append(const QByteArray &ba);
void QByteArray::push_back(const QByteArray &other);

头部添加数据

QByteArray &QByteArray::prepend(const QByteArray &ba);
void QByteArray::push_front(const QByteArray &other);

插入数据

// 将ba插入到数组第 i 个字节的位置(从0开始)
QByteArray &QByteArray::insert(int i, const QByteArray &ba);

删除数据

// 第pos个字符的位置开始删除len个字符
QByteArray &QByteArray::remove(int pos, int len);
// 从字符数组的尾部删除 n 个字节
void QByteArray::chop(int n);
// 从字节数组的 pos 位置将数组截断 (前边部分留下, 后边部分被删除)
void QByteArray::truncate(int pos);

清空

// 将其大小设置为 0，并释放其占用的内存
void QByteArray::clear();

字符串替换

// 将字节数组中的 子字符串 before 替换为 after
QByteArray &QByteArray::replace(const QByteArray &before, const QByteArray &after);
子字符串查找和判断

// 判断字节数组中是否包含子字符串 ba, 包含返回true, 否则返回false
bool QByteArray::contains(const QByteArray &ba) const;
bool QByteArray::contains(const char *ba) const;

// 判断字节数组中是否包含子字符 ch, 包含返回true, 否则返回false
bool QByteArray::contains(char ch) const;

// 判断字节数组是否以字符串 ba 开始, 是返回true, 不是返回false
bool QByteArray::startsWith(const QByteArray &ba) const;
bool QByteArray::startsWith(const char *ba) const;

// 判断字节数组是否以字符 ch 开始, 是返回true, 不是返回false
bool QByteArray::startsWith(char ch) const;

// 判断字节数组是否以字符串 ba 结尾, 是返回true, 不是返回false
bool QByteArray::endsWith(const QByteArray &ba) const;
bool QByteArray::endsWith(const char *ba) const;

// 判断字节数组是否以字符 ch 结尾, 是返回true, 不是返回false
bool QByteArray::endsWith(char ch) const;

遍历

// 使用迭代器
iterator QByteArray::begin();
iterator QByteArray::end();

// 使用数组的方式进行遍历
// i的取值范围 0 <= i < size()
char QByteArray::at(int i) const;
char QByteArray::operator[](int i) const;

查看字节数

// 返回字节数组对象中字符的个数
int QByteArray::length() const;
int QByteArray::size() const;
int QByteArray::count() const;

// 返回字节数组对象中 子字符串ba 出现的次数
int QByteArray::count(const QByteArray &ba) const;
int QByteArray::count(const char *ba) const;
// 返回字节数组对象中 字符串ch 出现的次数
int QByteArray::count(char ch) const;

类型转换

• QByteArray 转换为 char*

// 将QByteArray类型的字符串 转换为 char* 类型
char *QByteArray::data();
const char *QByteArray::data() const;

• 基本类型 转换为 QByteArray

QByteArray &QByteArray::setNum(int n, int base = 10);
QByteArray &QByteArray::setNum(short n, int base = 10);
QByteArray &QByteArray::setNum(qlonglong n, int base = 10);
QByteArray &QByteArray::setNum(float n, char f = 'g', int prec = 6);
QByteArray &QByteArray::setNum(double n, char f = 'g', int prec = 6);
[static] QByteArray QByteArray::number(int n, int base = 10);
[static] QByteArray QByteArray::number(qlonglong n, int base = 10);
[static] QByteArray QByteArray::number(double n, char f = 'g', int prec = 6);

• QByteArray 转换为 基本类型

int QByteArray::toInt(bool *ok = Q_NULLPTR, int base = 10) const;
short QByteArray::toShort(bool *ok = Q_NULLPTR, int base = 10) const;
long QByteArray::toLong(bool *ok = Q_NULLPTR, int base = 10) const;
float QByteArray::toFloat(bool *ok = Q_NULLPTR) const;
double QByteArray::toDouble(bool *ok = Q_NULLPTR) const;
std::string 转换为 QByteArray
[static] QByteArray QByteArray::fromStdString(const std::string &str);
// QByteArray -> std::string
std::string QByteArray::toStdString() const;

• 大小写转换

// 所有字符转换为大写
QByteArray QByteArray::toUpper() const;
// 所有字符转换为小写
QByteArray QByteArray::toLower() const;

2.2 QString

QString 内部使用 UTF-8 编码， UTF-8属于Unicode字符集（window为2字节, linux为3字节来表示一个字符）。

QString采用了写时复制（Copy-On-Write）的策略，这意味着当创建一个新的 QString 时，它不会立即复制数据，而是与原始字符串共享同一块内存。只有当其中一个字符串被修改时，才会进行实际的复制操作，这大大提高了内存使用效率。

构造函数

// 构造一个空字符串对象
QString::QString();
// 将 char* 字符串 转换为 QString 类型
QString::QString(const char *str);
// 将 QByteArray 转换为 QString 类型
QString::QString(const QByteArray &ba);
// 其他重载的同名构造函数可参考Qt帮助文档, 此处略

数据操作

// 尾部追加数据
// 其他重载的同名函数可参考Qt帮助文档, 此处略
QString &QString::append(const QString &str);
QString &QString::append(const char *str);
QString &QString::append(const QByteArray &ba);
void QString::push_back(const QString &other);

// 头部添加数据
// 其他重载的同名函数可参考Qt帮助文档, 此处略
QString &QString::prepend(const QString &str);
QString &QString::prepend(const char *str);
QString &QString::prepend(const QByteArray &ba);
void QString::push_front(const QString &other);

// 插入数据, 将 str 插入到字符串第 position 个字符的位置(从0开始)
// 其他重载的同名函数可参考Qt帮助文档, 此处略
QString &QString::insert(int position, const QString &str);
QString &QString::insert(int position, const char *str);
QString &QString::insert(int position, const QByteArray &str);

// 删除数据
// 从大字符串中删除len个字符, 从第pos个字符的位置开始删除
QString &QString::remove(int position, int n);

// 从字符串的尾部删除 n 个字符
void QString::chop(int n);
// 从字节串的 position 位置将字符串截断 (前边部分留下, 后边部分被删除)
void QString::truncate(int position);
// 将对象中的数据清空, 使其为null
void QString::clear();

// 字符串替换
// 将字节数组中的 子字符串 before 替换为 after
// 参数 cs 为是否区分大小写, 默认区分大小写
// 其他重载的同名函数可参考Qt帮助文档, 此处略
QString &QString::replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);

子字符串查找和判断

// 参数 cs 为是否区分大小写, 默认区分大小写
// 其他重载的同名函数可参考Qt帮助文档, 此处略

// 判断字符串中是否包含子字符串 str, 包含返回true, 否则返回false
bool QString::contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

// 判断字符串是否以字符串 ba 开始, 是返回true, 不是返回false
bool QString::startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

// 判断字符串是否以字符串 ba 结尾, 是返回true, 不是返回false
bool QString::endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

遍历

// 使用迭代器
iterator QString::begin();
iterator QString::end();

// 使用数组的方式进行遍历
// i的取值范围 0 <= position < size()
const QChar QString::at(int position) const
const QChar QString::operator[](int position) const;

查看字节数

// 返回字节数组对象中字符的个数 (字符个数和字节个数是不同的概念)
int QString::length() const;
int QString::size() const;
int QString::count() const;

// 返回字节串对象中 子字符串 str 出现的次数
// 参数 cs 为是否区分大小写, 默认区分大小写
int QString::count(const QStringRef &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

类型转换

// 将int, short, long, float, double 转换为 QString 类型
// 其他重载的同名函数可参考Qt帮助文档, 此处略
QString &QString::setNum(int n, int base = 10);
QString &QString::setNum(short n, int base = 10);
QString &QString::setNum(long n, int base = 10);
QString &QString::setNum(float n, char format = 'g', int precision = 6);
QString &QString::setNum(double n, char format = 'g', int precision = 6);
[static] QString QString::number(long n, int base = 10);
[static] QString QString::number(int n, int base = 10);
[static] QString QString::number(double n, char format = 'g', int precision = 6);

// 将 QString 转换为 int, short, long, float, double 类型
int QString::toInt(bool *ok = Q_NULLPTR, int base = 10) const;
short QString::toShort(bool *ok = Q_NULLPTR, int base = 10) const;
long QString::toLong(bool *ok = Q_NULLPTR, int base = 10) const
float QString::toFloat(bool *ok = Q_NULLPTR) const;
double QString::toDouble(bool *ok = Q_NULLPTR) const;

// 将标准C++中的 std::string 类型 转换为 QString 类型
[static] QString QString::fromStdString(const std::string &str);
// 将 QString 转换为 标准C++中的 std::string 类型
std::string QString::toStdString() const;

// QString -> QByteArray
// 转换为本地编码, 跟随操作系统
QByteArray QString::toLocal8Bit() const;
// 转换为 Latin-1 编码的字符串 不支持中文
QByteArray QString::toLatin1() const;
// 转换为 utf8 编码格式的字符串 (常用)
QByteArray QString::toUtf8() const;

// 所有字符转换为大写
QString QString::toUpper() const;
// 所有字符转换为小写
QString QString::toLower() const;

字符串格式

QString::arg() 用于在字符串中插入一个或多个参数。

格式化字符串中的占位符通常是 %1、%2、%3 等，它们表示要插入的参数的位置。arg() 函数会根据参数的数量和类型，将相应的值替换到占位符的位置。

#include   
#include   

int main() {  
  int number = 123;  
  QString message = "The number is: %1";  
  QString formattedMessage = message.arg(number);  
  qDebug() << formattedMessage; // 输出: The number is: 123
  
  double value = 123.456;  
  QString formattedValue = QString("Value: %1").arg(value, 0, 'f', 2);  
  qDebug() << formattedValue; // 输出: Value: 123.46
  
  return 0;  
}

3. QVariant

QVariant这个类型充当着最常见的数据类型的联合。QVariant 可以保存很多Qt的数据类型，包括QBrush、QColor、QCursor、QDateTime、QFont、QKeySequence、QPalette、QPen、QPixmap、QPoint、QRect、QRegion、QSize和QString，并且还有C++基本类型，如int、float等。

QVariant的主要作用是提供一种灵活的数据类型，方便在不同的函数、类、模块之间传递数据。

将标准类型转换为QVariant类型

可以使用QVariant类的构造函数

QVariant::QVariant(int val);
QVariant::QVariant(bool val);
QVariant::QVariant(double val);
QVariant::QVariant(const char *val);
QVariant::QVariant(const QByteArray &val);
QVariant::QVariant(const QString &val);
......

使用QVariant类的成员函数

// 这里的 T 类型, 就是QVariant支持的类型
void QVariant::setValue(const T &value);

// fromValue函数行为和 setValue() 函数完全相同
[static] QVariant QVariant::fromValue(const T &value);

//	示例
#if 1
QVariant v;
v.setValue(5);
#else
QVariant v = QVariant::fromValue(5);
#endif

int i = v.toInt();          // i is now 5
QString s = v.toString();   // s is now "5"

判断 QVariant中封装的实际数据类型

该函数的返回值是一个枚举类型, 可通过枚举值判断其数据类型

Type QVariant::type() const;

QVariant封装的标准类型对应的枚举

将QVariant对象转换为实际的数据类型

使用QVariant类提供的to目标类型()方法

// 在此举列举几个常用函数:
bool QVariant::toBool() const;
QByteArray QVariant::toByteArray() const;
double QVariant::toDouble(bool *ok = Q_NULLPTR) const;
float QVariant::toFloat(bool *ok = Q_NULLPTR) const;
int QVariant::toInt(bool *ok = Q_NULLPTR) const;
QString QVariant::toString() const;
......

3.1 自定义类型

QVariant能够存储任何可以通过QMetaType系统注册的类型，这包括Qt的内置类型以及通过Q_DECLARE_METATYPE宏注册的自定义类型。

被QVariant存储的数据类型需要有一个默认的构造函数和一个拷贝构造函数。

以下是将自定义类型转换为QVariant的示例步骤：

• 1. 注册自定义类型：使用Q_DECLARE_METATYPE宏来注册自定义类型，这样QVariant才能知道如何存储和转换它。

class MyCustomType {  
    // ... 自定义类型的定义 ...  
};  
 
Q_DECLARE_METATYPE(MyCustomType)

如果你在一个库中使用这个自定义类型，并且需要在不同的模块之间传递它，你还需要在模块的初始化函数中使用qRegisterMetaType< MyCustomType>("MyCustomType")来注册它。

• 2.创建QVariant对象：接下来，你可以使用QVariant的构造函数或者QVariant::fromValue()方法将你的自定义类型转换为QVariant。

使用构造函数：

MyCustomType myObject;  
// ... 初始化 myObject ...  
QVariant variant(myObject); // 使用构造函数直接将自定义类型转换为QVariant

或者使用fromValue()方法：

MyCustomType myObject;  
// ... 初始化 myObject ...  
QVariant variant = QVariant::fromValue(myObject);	// 使用fromValue()方法

• 3.使用QVariant：一旦你将自定义类型转换为QVariant，你就可以像使用任何其他QVariant一样使用它，比如将其传递给函数，存储在容器中，或者通过信号和槽机制进行传递。

• 4.从QVariant中恢复自定义类型：当你需要从QVariant中恢复你的自定义类型时，你可以使用QVariant::value< T>()模板函数。

if (variant.canConvert<MyCustomType>()) {  
    MyCustomType recoveredObject = variant.value<MyCustomType>();  
    // ... 使用 recoveredObject ...  
}

请注意，QVariant并不负责自定义类型的深拷贝或浅拷贝，它仅仅是一个容器。这意味着，如果你的自定义类型包含指针或其他需要特殊管理的资源，你需要自己负责这些资源的生命周期管理。此外，QVariant不会自动调用自定义类型的拷贝构造函数或析构函数，这些都需要你自己处理。

4. 位置和尺寸

QT中我们常见的 点, 线, 尺寸, 矩形 都被进行了封装

4.1 QPoint

QPoint类封装了我们常用用到的坐标点 (x, y)

// 构造函数
QPoint::QPoint();
// 参数为 x轴坐标, y轴坐标
QPoint::QPoint(int xpos, int ypos);

// 设置x轴坐标
void QPoint::setX(int x);
// 设置y轴坐标
void QPoint::setY(int y);

// 得到x轴坐标
int QPoint::x() const;
// 得到x轴坐标的引用
int &QPoint::rx();
// 得到y轴坐标
int QPoint::y() const;
// 得到y轴坐标的引用
int &QPoint::ry();

// 直接通过坐标对象进行算术运算: 加减乘除
QPoint &QPoint::operator*=(float factor);
QPoint &QPoint::operator*=(double factor);
QPoint &QPoint::operator*=(int factor);
QPoint &QPoint::operator+=(const QPoint &point);
QPoint &QPoint::operator-=(const QPoint &point);
QPoint &QPoint::operator/=(qreal divisor);

4.2 QLine

QLine是一个直线类, 封装了两个坐标点 (两点确定一条直线)

// 构造函数
// 构造一个空对象
QLine::QLine();
// 构造一条直线, 通过两个坐标点
QLine::QLine(const QPoint &p1, const QPoint &p2);
// 从点 (x1, y1) 到 (x2, y2)
QLine::QLine(int x1, int y1, int x2, int y2);

// 给直线对象设置坐标点
void QLine::setPoints(const QPoint &p1, const QPoint &p2);
// 起始点(x1, y1), 终点(x2, y2)
void QLine::setLine(int x1, int y1, int x2, int y2);
// 设置直线的起点坐标
void QLine::setP1(const QPoint &p1);
// 设置直线的终点坐标
void QLine::setP2(const QPoint &p2);

// 返回直线的起始点坐标
QPoint QLine::p1() const;
// 返回直线的终点坐标
QPoint QLine::p2() const;
// 返回值直线的中心点坐标, (p1() + p2()) / 2
QPoint QLine::center() const;

// 返回值直线起点的 x 坐标
int QLine::x1() const;
// 返回值直线终点的 x 坐标
int QLine::x2() const;
// 返回值直线起点的 y 坐标
int QLine::y1() const;
// 返回值直线终点的 y 坐标
int QLine::y2() const;

// 用给定的坐标点平移这条直线
void QLine::translate(const QPoint &offset);
void QLine::translate(int dx, int dy);
// 用给定的坐标点平移这条直线, 返回平移之后的坐标点
QLine QLine::translated(const QPoint &offset) const;
QLine QLine::translated(int dx, int dy) const;

// 直线对象进行比较
bool QLine::operator!=(const QLine &line) const;
bool QLine::operator==(const QLine &line) const;

4.3 QSize

在QT中QSize类用于表示一个二维对象的大小，具体来说，就是表示一个矩形的宽度和高度。

包含两个整数值：宽度（width）和高度（height）

// 构造函数
// 构造空对象, 对象中的宽和高都是无效的
QSize::QSize();
// 使用宽和高构造一个有效对象
QSize::QSize(int width, int height);

// 设置宽度
void QSize::setWidth(int width)
// 设置高度
void QSize::setHeight(int height);

// 得到宽度
int QSize::width() const;
// 得到宽度的引用
int &QSize::rwidth();
// 得到高度
int QSize::height() const;
// 得到高度的引用
int &QSize::rheight();

// 交换高度和宽度的值
void QSize::transpose();
// 交换高度和宽度的值, 返回交换之后的尺寸信息
QSize QSize::transposed() const;

// 进行算法运算: 加减乘除
QSize &QSize::operator*=(qreal factor);
QSize &QSize::operator+=(const QSize &size);
QSize &QSize::operator-=(const QSize &size);
QSize &QSize::operator/=(qreal divisor);

4.4 QRect

QRect类用于在二维平面上精确定义一个矩形

// 构造函数
// 构造一个空对象
QRect::QRect();
// 基于左上角坐标, 和右下角坐标构造一个矩形对象
QRect::QRect(const QPoint &topLeft, const QPoint &bottomRight);
// 基于左上角坐标, 和 宽度, 高度构造一个矩形对象
QRect::QRect(const QPoint &topLeft, const QSize &size);
// 通过 左上角坐标(x, y), 和 矩形尺寸(width, height) 构造一个矩形对象
QRect::QRect(int x, int y, int width, int height);

// 设置矩形的尺寸信息, 左上角坐标不变
void QRect::setSize(const QSize &size);
// 设置矩形左上角坐标为(x,y), 大小为(width, height)
void QRect::setRect(int x, int y, int width, int height);
// 设置矩形宽度
void QRect::setWidth(int width);
// 设置矩形高度
void QRect::setHeight(int height);

// 返回值矩形左上角坐标
QPoint QRect::topLeft() const;
// 返回矩形右上角坐标
// 该坐标点值为: QPoint(left() + width() -1, top())
QPoint QRect::topRight() const;
// 返回矩形左下角坐标
// 该坐标点值为: QPoint(left(), top() + height() - 1)
QPoint QRect::bottomLeft() const;
// 返回矩形右下角坐标
// 该坐标点值为: QPoint(left() + width() -1, top() + height() - 1)
QPoint QRect::bottomRight() const;
// 返回矩形中心点坐标
QPoint QRect::center() const;

// 返回矩形上边缘y轴坐标
int QRect::top() const;
int QRect::y() const;
// 返回值矩形下边缘y轴坐标
int QRect::bottom() const;
// 返回矩形左边缘 x轴坐标
int QRect::x() const;
int QRect::left() const;
// 返回矩形右边缘x轴坐标
int QRect::right() const;

// 返回矩形的高度
int QRect::width() const;
// 返回矩形的宽度
int QRect::height() const;
// 返回矩形的尺寸信息
QSize QRect::size() const;

5. 日期时间

5.1 QDate

QDate类可以封装日期信息也可以通过这个类得到日期相关的信息, 包括:年, 月, 日。

日期数据类型，仅表示日期，如：2024-01-01

// 构造函数
QDate::QDate();
QDate::QDate(int y, int m, int d);

// 公共成员函数
// 重新设置日期对象中的日期
bool QDate::setDate(int year, int month, int day);
// 给日期对象添加 ndays 天
QDate QDate::addDays(qint64 ndays) const;
// 给日期对象添加 nmonths 月
QDate QDate::addMonths(int nmonths) const;
// 给日期对象添加 nyears 月
QDate QDate::addYears(int nyears) const;

// 得到日期对象中的年/月/日
int QDate::year() const;
int QDate::month() const;
int QDate::day() const;
void QDate::getDate(int *year, int *month, int *day) const;


// 操作符重载 ==> 日期比较
bool QDate::operator!=(const QDate &d) const;
bool QDate::operator<(const QDate &d) const;
bool QDate::operator<=(const QDate &d) const;
bool QDate::operator==(const QDate &d) const;
bool QDate::operator>(const QDate &d) const;
bool QDate::operator>=(const QDate &d) const;

// 静态函数 -> 得到本地的当前日期
[static] QDate QDate::currentDate();

5.2 QTime

QTime类可以封装时间信息也可以通过这个类得到时间相关的信息, 包括:时, 分, 秒, 毫秒。

时间数据类型，仅表示时间，如：10:20:30

// 构造函数
QTime::QTime();
/*
    h 		==> 取值范围： 0 ~ 23
    m and s 	==> 取值范围： 0 ~ 59
    ms 		==> 取值范围： 0 ~ 999
*/ 
QTime::QTime(int h, int m, int s = 0, int ms = 0);

// 公共成员函数
// Returns true if the set time is valid; otherwise returns false.
bool QTime::setHMS(int h, int m, int s, int ms = 0);
QTime QTime::addSecs(int s) const;
QTime QTime::addMSecs(int ms) const;

// 示例代码
  QTime n(14, 0, 0);                // n == 14:00:00
  QTime t;
  t = n.addSecs(70);                // t == 14:01:10
  t = n.addSecs(-70);               // t == 13:58:50
  t = n.addSecs(10 * 60 * 60 + 5);  // t == 00:00:05
  t = n.addSecs(-15 * 60 * 60);     // t == 23:00:00

// 从时间对象中取出 时/分/秒/毫秒
int QTime::hour() const;	// 返回(0 to 23)，错误返回-1

int QTime::minute() const;	// 返回(0 to 59)，错误返回-1

int QTime::second() const;	// 返回(0 to 59)，错误返回-1

int QTime::msec() const;	// 返回(0 to 999)，错误返回-1

// 操作符重载 ==> 时间比较
bool QTime::operator!=(const QTime &t) const;
bool QTime::operator<(const QTime &t) const;
bool QTime::operator<=(const QTime &t) const;
bool QTime::operator==(const QTime &t) const;
bool QTime::operator>(const QTime &t) const;
bool QTime::operator>=(const QTime &t) const;

// 静态函数 -> 得到当前时间
[static] QTime QTime::currentTime();
阶段性计时

// 推荐使用QElapsedTimer 类
void QElapsedTimer::start();			// 开始计时
qint64 QElapsedTimer::restart();		// 计时结束
qint64 QElapsedTimer::elapsed() const;	// 重新计时

// 过时的计时API函数
void QTime::start();
int QTime::elapsed() const;
int QTime::restart();

5.3 QDateTime

QDateTime类封装日期和时间信息，QDateTime类就是QDate 和 QTime 这两个类的结合体。

// 构造函数
QDateTime::QDateTime();
QDateTime::QDateTime(const QDate &date, const QTime &time, Qt::TimeSpec spec = Qt::LocalTime);

// 公共成员函数
// 设置日期
void QDateTime::setDate(const QDate &date);
// 设置时间
void QDateTime::setTime(const QTime &time);
// 给当前日期对象追加 年/月/日/秒/毫秒, 参数可以是负数
QDateTime QDateTime::addYears(int nyears) const;
QDateTime QDateTime::addMonths(int nmonths) const;
QDateTime QDateTime::addDays(qint64 ndays) const;
QDateTime QDateTime::addSecs(qint64 s) const;
QDateTime QDateTime::addMSecs(qint64 msecs) const;

// 得到对象中的日期
QDate QDateTime::date() const;
// 得到对象中的时间
QTime QDateTime::time() const;

// 日期和时间格式, 格式字符参考QDate 和 QTime 类的 toString() 函数
QString QDateTime::toString(const QString &format) const;


// 操作符重载 ==> 日期时间对象的比较
bool QDateTime::operator!=(const QDateTime &other) const;
bool QDateTime::operator<(const QDateTime &other) const;
bool QDateTime::operator<=(const QDateTime &other) const;
bool QDateTime::operator==(const QDateTime &other) const;
bool QDateTime::operator>(const QDateTime &other) const;
bool QDateTime::operator>=(const QDateTime &other) const;

// 静态函数
// 得到当前时区的日期和时间(本地设置的时区对应的日期和时间)
[static] QDateTime QDateTime::currentDateTime();

5.4 日期时间格式与转换

日期时间转字符串

QString toString(const QString &format) const	
    
//	示例
QTimecurTime= QTime::currentTime();
QStringtime = curTime.toString(" HH:mm:ss");

字符串转换成日期时间

QTime QTime::fromString(const QString &string, const QString &format);
QDate QDate::fromString(const QString &string, const QString &format);
QDateTime QDateTime::fromString(const QString &string, const QString &format);

//	示例(
QTime time = QTime::fromString("09:10:10" ,  "HH:mm:ss");
QDate date = QDate::fromString("2022-10-01" ,"yyyy-MM-dd");
QDateTime dateTime = QDateTime::fromString(
     "2022-10-01 09:10:10"," yyyy-MM-dd HH:mm:ss");

• 日期格式
  | 格式符号 | 含义 |
  | — | — |
  | d | 没有前导零的日期(1~31) |
  | dd | 有前导零的日期(01~31) |
  | ddd | 本地日期名缩写(如：Mon~Sun) |
  | dddd | 本地日期名(如：Monday~Sunday) |
  | M | 没有前导零的月份(1~12) |
  | MM | 有前导零的月份(01~12) |
  | MMM | 本地月份名称缩写(如：Jan~Dec) |
  | MMMM | 本地月份名称(如：January~December) |
  | yy | 两位数字的年份(00~99) |
  | yyyy | 四位数字的年份 |

• 时间格式
  | 格式符号 | 含义 |
  | — | — |
  | h | 没有前导零的小时(0 to 23 or 1 to 12 if AM/PM display) |
  | hh | 有前导零的小时(00 to 23 or 01 to 12 if AM/PM display) |
  | H | 没有前导零的小时(0 to 23, even with AM/PM display) |
  | HH | 有前导零的小时(0 to 23, even with AM/PM display) |
  | m | 没有前导零的分钟(0~59) |
  | mm | 有前导零的分钟(00~59) |
  | s | 没有前导零的秒(0~59) |
  | ss | 有前导零的秒(00~59) |
  | z | 没有尾随零的毫秒(0~999) |
  | zzz | 有尾随零的毫秒(000~999) |
  | AP / A | 显示AM/PM(大写) |
  | ap / a | 显示am/pm(小写) |

示例

#include "datetime.h"
#include "ui_datetime.h"

#include
#include
#include

#include
#include
#include


DateTime::DateTime(QWidget *parent)    : QDialog(parent), ui(new Ui::DateTime){
    ui->setupUi(this);
}

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

void DateTime::on_m_get_clicked()			// 点击获取显示当前时间
{
    QDateTime datetime = QDateTime::currentDateTime();
    ui->m_dateEdit->setDate(datetime.date());
    ui->m_timeEdit->setTime(datetime.time());
    ui->m_dateTimeEdit->setDateTime(datetime);

    ui->m_EditDate->setText(datetime.date().toString(ui->m_dateEdit->displayFormat()));
    ui->m_EditTime->setText(datetime.time().toString(ui->m_timeEdit->displayFormat()));
    ui->m_EditDateTime->setText(datetime.toString(ui->m_dateTimeEdit->displayFormat()));
}

void DateTime::on_m_set_clicked()
{
    ui->m_dateEdit->setDate(QDate::fromString(ui->m_EditDate->text(),ui->m_dateEdit->displayFormat()));
    ui->m_timeEdit->setTime(QTime::fromString(ui->m_EditTime->text(),ui->m_timeEdit->displayFormat()));
    ui->m_dateTimeEdit->setDateTime(QDateTime::fromString(ui->m_EditDateTime->text(),ui->m_dateTimeEdit->displayFormat()));
}

void DateTime::on_m_calendar_selectionChanged()	//	点击日历中的某一天显示日期
{
    ui->m_calendarEdit->setText(
        ui->m_calendar->selectedDate().toString(ui->m_dateEdit->displayFormat()) );
}

Qt基础：数据类型
Qt-常用数据类型
Qt中的各种"q+基本数据类型"
Qt6数据类型-qint8、quint8、qint16、quint16、qint32、quint32、qint64、quint64、uint、qlonglong、uchar、double
QT基本数据类型（以前没见过qintptr和qlonglong）
QT 中的自带数据类型和 C++ 中的数据类型的区别有哪些