Qt 常用数据类型

Qt 常用数据类型

1. 基础类型

1. 1 基础数据类型

因为Qt是一个C++框架，因此C++中所有的语法和数据类型在Qt中都是被支持的，但是Qt中也定义了一些属于自己的数据类型。

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

类型名称	注释	说明
qint8	signed char	有符号8位数据类型，表示范围为 -2⁷ 到 2⁷-1
qint16	signed short	有符号16位数据类型，表示范围为 -2¹⁵ 到 2¹⁵-1
qint32	signed int	有符号32位数据类型，表示范围为 -2³¹ 到 2³¹-1
qint64	long long int 或 (__int64)	64位有符号数据类型，Windows中定义为__int64，表示范围为 -2⁶³ 到 2⁶³-1
qintptr	qint32 或 qint64	指针类型，根据系统类型不同而不同，32位系统为qint32、64位系统为qint64，用于存储指针值
qlonglong	long long int 或(__int64)	64位有符号数据类型，Windows中定义为__int64，与qint64相同
qptrdiff	qint32 或 qint64	根据系统类型不同而不同，32位系统为qint32、64位系统为qint64，用于表示指针差值
qreal	double 或 float	浮点数类型，除非配置了-qreal float选项，否则默认为double
quint8	unsigned char	无符号8位数据类型，表示范围为 0 到 2⁸-1
quint16	unsigned short	无符号16位数据类型，表示范围为 0 到 2¹⁶-1
quint32	unsigned int	无符号32位数据类型，表示范围为 0 到 2³²-1
quint64	unsigned long long int 或 (unsigned __int64)	无符号64位数据类型，Windows中定义为unsigned __int64，表示范围为 0 到 2⁶⁴-1
quintptr	quint32 或 quint64	指针类型，根据系统类型不同而不同，32位系统为quint32、64位系统为quint64，用于存储无符号指针值
qulonglong	unsigned long long int 或 (unsigned __int64)	无符号64位数据类型，Windows中定义为unsigned __int64，与quint64相同
uchar	unsigned char	无符号字符类型，表示范围为 0 到 2⁸-1
uint	unsigned int	无符号整型，表示范围为 0 到 2³²-1
ulong	unsigned long	无符号长整型，表示范围依赖于平台，在32位系统上通常为 0 到 2³²-1，在64位系统上通常为 0 到 2⁶⁴-1
ushort	unsigned short	无符号短整型，表示范围为 0 到 2¹⁶-1
qsizetype	size_t	用于表示容器大小和数组索引，通常为有符号整数，以确保在不同平台上的一致性

详细说明

• qint8, qint16, qint32, qint64, qlonglong：这些类型用于表示不同位宽的有符号整数，适用于需要精确控制数据大小的场景。
• quint8, quint16, quint32, quint64, qulonglong：这些类型用于表示不同位宽的无符号整数，适用于需要正整数且不需要负值的场景。
• qintptr, quintptr：用于存储指针值的有符号和无符号整数类型，适用于跨平台的指针运算。
• qptrdiff：用于表示两个指针之间的差值。
• qreal：默认情况下为 double 类型，可以通过配置更改为 float，适用于需要高精度浮点数运算的场景。
• uchar, uint, ulong, ushort：这些类型与标准的 C++ 类型类似，但使用在 Qt 中可以提高代码的可读性和一致性。
• qsizetype： 尺寸类型用于表示容器大小和数组索引，确保在不同平台上的一致性和安全性，通常为有符号整数。

1.2 字符串和文本处理

类型名称	注释	说明
QString	字符串类	用于处理 Unicode 字符串。
QByteArray	字节数组类	用于处理二进制数据。
QVariant	变体类	可以存储和转换多种数据类型。

详细说明

• QString: QString 是一种用于处理 Unicode 字符串的类，提供了丰富的字符串操作功能，如拼接、查找、替换、拆分等。

  QString str = "Hello, Qt!";
  qDebug() << str.toUpper();  // 输出 "HELLO, QT!"
  

• QByteArray: QByteArray 是一种用于处理二进制数据的类，可以存储任意字节数据，常用于文件读写、网络通信等场景。

  QByteArray byteArray = "Hello, QByteArray!";
  qDebug() << byteArray.toHex();  // 输出 "48656c6c6f2c205142797465417272617921"
  

• QVariant: QVariant 是一种可以存储和转换多种数据类型的变体类，常用于需要存储不同类型数据的场景，如数据库操作、动态属性等。

  QVariant variant = 42;
  qDebug() << variant.toString();  // 输出 "42"
  

1.3 日期和时间

类型名称	注释	说明
QDate	日期类	用于处理日期。
QTime	时间类	用于处理时间。
QDateTime	日期时间类	同时处理日期和时间。

详细说明

• QDate: QDate 类用于处理日期，可以获取当前日期、进行日期运算、格式化输出等。

  QDate date = QDate::currentDate();
  qDebug() << date.toString(Qt::ISODate);  // 输出 "2023-10-23"（假设今天是 2023 年 10 月 23 日）
  

• QTime: QTime 类用于处理时间，可以获取当前时间、进行时间运算、格式化输出等。

  QTime time = QTime::currentTime();
  qDebug() << time.toString(Qt::ISODate);  // 输出 "14:30:15"（假设当前时间是 14:30:15）
  

• QDateTime: QDateTime 类同时处理日期和时间，提供了日期和时间的组合操作。

  QDateTime dateTime = QDateTime::currentDateTime();
  qDebug() << dateTime.toString(Qt::ISODate);  // 输出 "2023-10-23T14:30:15"（假设当前日期和时间）
  

1.4 数学和几何

类型名称	注释	说明
QPoint	二维点类	用于表示二维空间中的点，由 x 和 y 坐标组成。
QSize	尺寸类	用于表示尺寸，有宽度和高度。
QRect	矩形类	用于表示矩形区域，由左上角的坐标和尺寸组成。
QLine	线段类	用于表示线段，由两个点组成。
QMargins	边距类	用于表示四个边距（左、上、右、下）。

详细说明

• QPoint: QPoint 类用于表示二维空间中的点，包含 x 和 y 坐标。

  QPoint point(10, 20);
  qDebug() << point;  // 输出 "(10, 20)"
  

• QSize: QSize 类用于表示尺寸，包含宽度和高度。

  QSize size(100, 200);
  qDebug() << size;  // 输出 "QSize(100, 200)"
  

• QRect: QRect 类用于表示矩形区域，由左上角的坐标和尺寸组成。

  QRect rect(10, 20, 100, 200);
  qDebug() << rect;  // 输出 "QRect(10, 20, 100, 200)"
  

• QLine: QLine 类用于表示线段，由两个点组成。

  QLine line(QPoint(0, 0), QPoint(100, 100));
  qDebug() << line;  // 输出 "QLine(0, 0, 100, 100)"
  

• QMargins: QMargins 类用于表示四个边距（左、上、右、下）。

  QMargins margins(1, 2, 3, 4);
  qDebug() << margins;  // 输出 "QMargins(1, 2, 3, 4)"
  

1.5 颜色和图形

类型名称	注释	说明
QColor	颜色类	用于描述颜色，支持 RGB、RGBA、HSV 等色彩模式。
QPen	画笔类	用于绘制线条和轮廓。
QBrush	画刷类	用于填充形状。
QFont	字体类	用于描述文本的字体样式。
QPalette	调色板类	存储应用程序的配色方案。
QImage	图像类	用于表示和操作图像。
QPixmap	像素图类	高效的图像表示，通常用于显示。

详细说明

• QColor: QColor 类用于描述颜色，支持多种色彩模式，如 RGB、RGBA、HSV 等。

  QColor color(Qt::red);
  qDebug() << color.name();  // 输出 "#ff0000"
  

• QPen: QPen 类用于绘制线条和轮廓，包含颜色、宽度、样式等属性。

  QPen pen(Qt::black);
  pen.setWidth(2);
  qDebug() << pen.color();  // 输出 "QColor(ARGB 1, 0, 0, 0)"
  

• QBrush: QBrush 类用于填充形状，包含颜色、纹理、图案等属性。

  QBrush brush(Qt::SolidPattern);
  brush.setColor(Qt::green);
  qDebug() << brush.color();  // 输出 "QColor(ARGB 1, 0, 1, 0)"
  

• QFont: QFont 类用于描述文本的字体样式，支持多种字体属性，如字体族、大小、加粗、斜体等。

  QFont font("Arial", 12);
  qDebug() << font.family();  // 输出 "Arial"
  

• QPalette: QPalette 类用于存储应用程序的配色方案，包含窗口、按钮、文本等多种颜色角色。

  QPalette palette;
  palette.setColor(QPalette::Window, Qt::blue);
  qDebug() << palette.color(QPalette::Window);  // 输出 "QColor(ARGB 1, 0, 0, 1)"
  

• QImage: QImage 类用于表示和操作图像，提供了像素级别的读写访问功能，适合图像处理。

  QImage image(100, 100, QImage::Format_RGB32);
  image.fill(Qt::white);
  qDebug() << image.size();  // 输出 QSize(100, 100)
  

• QPixmap: QPixmap 类是一个高效的图像表示，通常用于在屏幕上显示图像，不适合像素级别的操作。

  QPixmap pixmap(100, 100);
  pixmap.fill(Qt::blue);
  // 通常用在绘图控件中，例如 QLabel
  

1.6 数据结构

类型名称	注释	说明
QList	列表容器类	动态数组，用于存储元素列表。
QVector	向量容器类	动态数组，与 QList 类似，但通常在性能要求更高的情况下使用。
QMap	映射容器类	键值对容器，基于红黑树实现。
QHash	哈希表容器类	键值对容器，使用哈希表实现。
QSet	集合容器类	集合类。
QPair	对类	存储一对值。

详细说明

• QList: QList 是一种动态数组，用于存储元素列表，支持快速的随机访问和插入/删除操作。

  QList<int> list;
  list << 1 << 2 << 3;
  qDebug() << list;  // 输出 "(1, 2, 3)"
  

• QVector: QVector 是一种动态数组，与 QList 类似，但在一些场景下性能更好，尤其是需要频繁访问和修改元素时。

  QVector<int> vector;
  vector << 1 << 2 << 3;
  qDebug() << vector;  // 输出 "(1, 2, 3)"
  

• QMap: QMap 是一种键值对容器，使用平衡二叉树实现，支持按键排序和快速查找。

  QMap<QString, int> map;
  map["one"] = 1;
  map["two"] = 2;
  qDebug() << map;  // 输出 "{ "one" : 1, "two" : 2 }"
  

• QHash: QHash 是一种键值对容器，使用哈希表实现，支持快速查找和插入。

  QHash<QString, int> hash;
  hash["one"] = 1;
  hash["two"] = 2;
  qDebug() << hash;  // 输出 "{ "one" : 1, "two" : 2 }"
  

• QSet: QSet 是一种集合类，用于存储唯一的元素，不允许重复。

  QSet<int> set;
  set << 1 << 2 << 3 << 2;
  qDebug() << set;  // 输出 "{ 1, 2, 3 }"
  

• QPair: QPair 用于存储一对值，常用于需要返回两个值的场景。

  QPair<QString, int> pair = qMakePair(QString("apple"), 5);
  qDebug() << pair;  // 输出 "( "apple", 5 )"
  

1.7 文件 IO 操作和 JSON 解析

类型名称	注释	说明
QFile	文件类	用于读写文件。
QDir	目录类	用于操作文件系统中的目录。
QFileInfo	文件信息类	用于获取文件的元数据。
QJsonDocument	JSON 文档类	用于解析和生成 JSON 文档。
QJsonObject	JSON 对象类	用于表示和操作 JSON 对象。
QJsonArray	JSON 数组类	用于表示和操作 JSON 数组。
QJsonValue	JSON 值类	用于表示和操作 JSON 值。

详细说明

• QFile: QFile 类用于读写文件，提供了打开、关闭、读写等文件操作方法。

  QFile file("test.txt");
  if (file.open(QIODevice::ReadWrite))
  {file.write("Hello, QFile!");file.close();
  }
  

• QDir: QDir 类用于操作文件系统中的目录，提供了创建、删除、遍历目录等方法。

  QDir dir;
  qDebug() << dir.currentPath();  // 输出当前工作目录路径
  

• QFileInfo: QFileInfo 类用于获取文件的元数据，如文件路径、大小、创建时间等。

  QFileInfo fileInfo(file);
  qDebug() << fileInfo.absoluteFilePath();  // 输出文件的绝对路径
  

• QJsonDocument: QJsonDocument 类用于解析和生成 JSON 文档，可以从字符串或文件加载 JSON 数据。

  QString jsonString = R"({"name": "Qt", "version": 6.0})";
  QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonString.toUtf8());
  QJsonObject jsonObj = jsonDoc.object();
  qDebug() << jsonObj["name"].toString();  // 输出 "Qt"
  

• QJsonObject: QJsonObject 类用于表示和操作 JSON 对象，可以通过键值对存储数据。

  QJsonObject jsonObj;
  jsonObj["name"] = "Qt";
  jsonObj["version"] = 6.0;
  QJsonDocument jsonDoc(jsonObj);
  qDebug() << jsonDoc.toJson();  // 输出 {"name":"Qt","version":6}
  

• QJsonArray: QJsonArray 类用于表示和操作 JSON 数组，可以存储多个 JSON 值。

  QJsonArray jsonArray;
  jsonArray.append("Qt");
  jsonArray.append(6.0);
  QJsonDocument jsonDoc(jsonArray);
  qDebug() << jsonDoc.toJson();  // 输出 ["Qt",6]
  

• QJsonValue: QJsonValue 类用于表示和操作 JSON 值，可以是字符串、数值、对象、数组或布尔值。

  QJsonValue jsonValue("Qt");
  qDebug() << jsonValue.toString();  // 输出 "Qt"
  

1.8 本地化和国际化

类型名称	注释	说明
QLocale	本地化信息类	用于处理与地区相关的信息，如货币、日期格式等。

详细说明

• QLocale: QLocale 类用于处理与地区相关的信息，如货币、日期格式、数字格式等，支持多种本地化设置。

  QLocale locale(QLocale::English, QLocale::UnitedStates);
  qDebug() << locale.toString(QDate::currentDate());  // 输出 "MM/dd/yyyy" 格式的日期
  

1.9 网络编程和 URL

Qt 提供了丰富的网络编程支持，包括 HTTP 请求、TCP/UDP 通信、网络服务等。

类型名称	注释	说明
QTcpSocket	TCP 套接字类	用于 TCP 网络通信。
QUdpSocket	UDP 套接字类	用于 UDP 网络通信。
QNetworkAccessManager	网络访问管理器类	用于发送 HTTP 请求。
QUrl	URL 类	用于处理 URL。

详细说明

• QTcpSocket: QTcpSocket 类用于 TCP 网络通信，可以用于建立 TCP 客户端。

  QTcpSocket *tcpSocket = new QTcpSocket;
  tcpSocket->connectToHost("example.com", 80);
  if (tcpSocket->waitForConnected()) 
  {qDebug() << "Connected to server";tcpSocket->write("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n");if (tcpSocket->waitForReadyRead()) {qDebug() << tcpSocket->readAll();}
  }
  

• QUdpSocket: QUdpSocket 类用于 UDP 网络通信，可以用于发送和接收 UDP 数据报。

  QUdpSocket *udpSocket = new QUdpSocket;
  udpSocket->bind(QHostAddress::LocalHost, 12345);
  connect(udpSocket, &QUdpSocket::readyRead, [=]() {while (udpSocket->hasPendingDatagrams()) {QByteArray datagram;datagram.resize(udpSocket->pendingDatagramSize());udpSocket->readDatagram(datagram.data(), datagram.size());qDebug() << "Received datagram:" << datagram;}
  });
  

• QNetworkAccessManager: QNetworkAccessManager 类用于发送 HTTP 请求，支持 GET、POST 等 HTTP 方法。

  QNetworkAccessManager *networkManager = new QNetworkAccessManager;
  QNetworkRequest request(QUrl("http://example.com"));
  QNetworkReply *reply = networkManager->get(request);
  connect(reply, &QNetworkReply::finished, [=]() {if (reply->error() == QNetworkReply::NoError) {QByteArray response = reply->readAll();qDebug() << response;}reply->deleteLater();
  });
  

• QUrl: QUrl 类用于处理 URL，支持解析、构建和操作 URL。

  QUrl url("http://www.example.com");
  qDebug() << url.host();  // 输出 "www.example.com"
  

这些分类和详细说明应该有助于理解和使用 Qt 的各种基础数据类型。详细的 API 和更多的用法可以参考 Qt 官方文档。

2. 字符串类型

C => char*

C++ => std::string

Qt => QByteArray, QString

2.1 QByteArray

在 Qt 中，QByteArray 可以被视为 C 语言中 char* 的升级版本。使用这种类型时，可以通过该类的构造函数申请一块动态内存，用于存储需要处理的字符串数据。

以下是 QByteArray 类中常用的一些 API 函数介绍。

构造函数

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

数据操作

// 其他重载的同名函数可参考Qt帮助文档, 此处略
QByteArray &QByteArray::append(const QByteArray &ba);
void QByteArray::push_back(const QByteArray &other);// 其他重载的同名函数可参考Qt帮助文档, 此处略
QByteArray &QByteArray::prepend(const QByteArray &ba);
void QByteArray::push_front(const QByteArray &other);// 插入数据, 将ba插入到数组第 i 个字节的位置(从0开始)
// 其他重载的同名函数可参考Qt帮助文档, 此处略
QByteArray &QByteArray::insert(int i, const QByteArray &ba);// 删除数据
// 从大字符串中删除len个字符, 从第pos个字符的位置开始删除
QByteArray &QByteArray::remove(int pos, int len);
// 从字符数组的尾部删除 n 个字节
void QByteArray::chop(int n);
// 从字节数组的 pos 位置将数组截断 (前边部分留下, 后边部分被删除)
void QByteArray::truncate(int pos);
// 将对象中的数据清空, 使其为null
void QByteArray::clear();// 字符串替换
// 将字节数组中的 子字符串 before 替换为 after
// 其他重载的同名函数可参考Qt帮助文档, 此处略
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* 类型
char *QByteArray::data();
const char *QByteArray::data() const;// int, short, long, float, double -> QByteArray
// 其他重载的同名函数可参考Qt帮助文档, 此处略
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, short, long, float, double
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;

示例代码

以下是一些示例代码，展示了 QByteArray 的常见用法：

#include <QCoreApplication>
#include <QDebug>
#include <QByteArray>int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);// 构造函数示例QByteArray byteArray1; // 空的 QByteArrayQByteArray byteArray2("Hello, World!"); // 从 const char* 构造QByteArray byteArray3(10, 'a'); // 长度为 10，每个字节为 'a'// 数据操作示例byteArray1.append("Appending data");byteArray2.prepend("Prepending data ");byteArray3.insert(5, "Inserted data");byteArray2.replace("World", "Qt");qDebug() << byteArray1;qDebug() << byteArray2;qDebug() << byteArray3;// 查找和判断示例bool contains = byteArray2.contains("Qt");bool startsWith = byteArray2.startsWith("Prepending");bool endsWith = byteArray2.endsWith("data");qDebug() << "Contains 'Qt':" << contains;qDebug() << "Starts with 'Prepending':" << startsWith;qDebug() << "Ends with 'data':" << endsWith;// 类型转换示例QByteArray numberArray = QByteArray::number(12345);int number = numberArray.toInt();qDebug() << "Number array:" << numberArray;qDebug() << "Converted to int:" << number;return a.exec();
}

这些示例代码展示了 QByteArray 在构造、数据操作、查找和判断以及类型转换等方面的常见用法。详细的 API 和更多的用法可以参考 Qt 官方文档。

2.2 QString

QString 是 Qt 中用于处理字符串的类，其内部采用 UTF-8 编码。UTF-8 是一种 Unicode 字符集，能够使用多个字节（在 Windows 中为 2 字节，在 Linux 中为 3 字节）表示一个字符，从而支持几乎所有语言的常用字符。

以下是 QString 类中常用的一些 API 函数介绍。

构造函数

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

数据操作

// 尾部追加数据
QString& append(const QString &str);
QString& append(const char *str);
QString& append(const QByteArray &ba);
void push_back(const QString &other);// 头部添加数据
QString& prepend(const QString &str);
QString& prepend(const char *str);
QString& prepend(const QByteArray &ba);
void QString::push_front(const QString &other);// 插入数据, 将 str 插入到字符串第 position 个字符的位置(从0开始)
QString& insert(int position, const QString &str);
QString& insert(int position, const char *str);
QString& insert(int position, const QByteArray &str);// 删除数据
// 从大字符串中删除len个字符, 从第pos个字符的位置开始删除
QString& remove(int position, int n);// 从字符串的尾部删除 n 个字符
void  chop(int n);
// 从字节串的 position 位置将字符串截断 (前边部分留下, 后边部分被删除)
void  truncate(int position);
// 将对象中的数据清空, 使其为null
void  clear();// 字符串替换
// 将字节数组中的 子字符串 before 替换为 after
// 参数 cs 为是否区分大小写, 默认区分大小写
QString& replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);

子字符串查找和判断

// 参数 cs 为是否区分大小写, 默认区分大小写
// 其他重载的同名函数可参考Qt帮助文档, 此处略// 判断字符串中是否包含子字符串 str, 包含返回true, 否则返回false
bool  contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;// 判断字符串是否以字符串 ba 开始, 是返回true, 不是返回false
bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;// 判断字符串是否以字符串 ba 结尾, 是返回true, 不是返回false
bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

遍历

// 使用迭代器
iterator  begin();
iterator  end();// 使用数组的方式进行遍历
const QChar  at(int position) const
const QChar  operator[](int position) const;

查看字节数

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

类型转换

// int, short, long, float, double -> QString
// 其他重载的同名函数可参考Qt帮助文档, 此处略
QString& setNum(int n, int base = 10);
QString& setNum(short n, int base = 10);
QString& setNum(long n, int base = 10);
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;// 所有字符转换为大写
QString QString::toUpper() const;
// 所有字符转换为小写
QString QString::toLower() const;

字符串格式化

类似于 C 语言中的 sprintf() 函数，QString 也提供了一个 asprintf() 函数，以及更方便的 arg() 函数。

 QString res =  asprintf("fileName:%s size:%d","./av.jpg",20);qDebug()<<res<<endl;

不过QString还提供的另一种格式化字符串输出的函数arg()，更为方便。

QString arg(const QString &a, int fieldWidth = 0, QChar fillChar = QLatin1Char( ' ' )) const;
QString arg(int a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char( ' ' )) const;
//用于填充字符串中的%1,%2…为给定格式的整形数字，其中第一个参数是要填充的数字，第二个参数为最小宽度，第三个参数为进制，第四个参数为当原始数字长度不足最小宽度时用于填充的字符// 示例程序
QString str =  QString("%1 %2 %3").arg(1).arg(2);
str = str.arg("hello");
qDebug()<<str<<endl;     //"hello 2 1"QString text = QString("%1:%2:%3").arg(1,2,10,QChar('0')).arg(35).arg(59);
qDebug()<<text<<endl;    //"01:35:59"

示例代码

#include <QCoreApplication>
#include <QDebug>
#include <QString>int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);// 构造函数示例QString string1; // 空的 QStringQString string2("Hello, World!"); // 从 const char* 构造QString string3(QByteArray("Hello from QByteArray")); // 从 QByteArray 构造// 数据操作示例string1.append("Appending data");string2.prepend("Prepending data ");string3.insert(5, "Inserted data");string2.replace("World", "Qt");qDebug() << string1;qDebug() << string2;qDebug() << string3;// 查找和判断示例bool contains = string2.contains("Qt");bool startsWith = string2.startsWith("Prepending");bool endsWith = string2.endsWith("data");qDebug() << "Contains 'Qt':" << contains;qDebug() << "Starts with 'Prepending':" << startsWith;qDebug() << "Ends with 'data':" << endsWith;// 类型转换示例QString numberString = QString::number(12345);int number = numberString.toInt();qDebug() << "Number string:" << numberString;qDebug() << "Converted to int:" << number;// 格式化字符串示例QString formattedString = QString("%1 %2 %3").arg(1).arg(2).arg("Hello");qDebug() << formattedString;QString timeString = QString("%1:%2:%3").arg(1, 2, 10, QChar('0')).arg(35).arg(59);qDebug() << timeString;return a.exec();
}

这些示例代码展示了 QString 在构造、数据操作、查找和判断、类型转换以及字符串格式化等方面的常见用法。详细的 API 和更多的用法可以参考 Qt 官方文档。

2.3 不同字符串类型相互转换

在 Qt 中，不同字符串类型之间的转换是非常常见的操作。以下是一些常用的转换方法：

std::string 与 QString 之间的转换

// std::string -> QString
[static] QString QString::fromStdString(const std::string &str);// QString -> std::string
std::string QString::toStdString() const;

QString 与 QByteArray 之间的转换

QString 可以转换为多种编码格式的 QByteArray，也可以通过构造函数从 QByteArray 转换为 QString。

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

QByteArray 转换为 QString

从 QByteArray 转换为 QString 可以直接使用 QString 的构造函数。

// 使用 QString 的构造函数进行转换
QString::QString(const QByteArray &ba);

示例代码

以下示例展示了不同字符串类型之间的转换：

#include <QCoreApplication>
#include <QDebug>
#include <QString>
#include <QByteArray>
#include <string>int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);// std::string 与 QString 的转换std::string stdStr = "Hello, std::string!";QString qStrFromStd = QString::fromStdString(stdStr);std::string stdStrFromQ = qStrFromStd.toStdString();qDebug() << "std::string to QString:" << qStrFromStd;qDebug() << "QString to std::string:" << QString::fromStdString(stdStrFromQ);// QString 与 QByteArray 的转换QString qStr = "Hello, QString!";QByteArray byteArrayLocal = qStr.toLocal8Bit();QByteArray byteArrayLatin1 = qStr.toLatin1();QByteArray byteArrayUtf8 = qStr.toUtf8();qDebug() << "QString to Local8Bit:" << byteArrayLocal;qDebug() << "QString to Latin1:" << byteArrayLatin1;qDebug() << "QString to Utf8:" << byteArrayUtf8;// QByteArray 转换为 QStringQByteArray byteArray = "Hello from QByteArray!";QString qStrFromByteArray(byteArray);qDebug() << "QByteArray to QString:" << qStrFromByteArray;return a.exec();
}

这些示例代码展示了如何在 Qt 中进行不同字符串类型之间的转换，包括 std::string 与 QString、QString 与 QByteArray 之间的相互转换。详细的 API 和更多的用法可以参考 Qt 官方文档。

3. QVariant

QVariant(变体数据类型)这个类很神奇，或者说方便。很多时候，需要几种不同的数据类型需要传递，如果用结构体，又不大方便，容器保存的也只是一种数据类型，而QVariant则可以统统搞定。

QVariant 充当了各种常见数据类型的联合体。它能够保存许多 Qt 的数据类型，包括 QBrush、QColor、QCursor、QDateTime、QFont、QKeySequence、QPalette、QPen、QPixmap、QPoint、QRect、QRegion、QSize 和 QString，以及一些 C++ 的基本类型，如 int、float 等。

3.1 标准类型

将标准类型转换为 QVariant 类型

使用 QVariant 类的构造函数，可以将多种标准数据类型转换为 QVariant 类型。以下展示了一些常用的构造函数：

// 这类转换需要使用QVariant类的构造函数, 由于比较多, 大家可自行查阅Qt帮助文档, 在这里简单写几个
QVariant(int val);
QVariant(bool val);
QVariant(double val);
QVariant(const char *val);
QVariant(const QByteArray &val);
QVariant(const QString &val);
// 其他构造函数请参考 Qt 官方文档

还可以使用设置函数将支持的类型的数据设置到 QVariant 对象中：

// 使用设置函数也可以将支持的类型的数据设置到QVariant对象中
// 这里的 T 类型, 就是QVariant支持的类型
void setValue(const T &value);// 该函数行为和 setValue() 函数完全相同
[static] QVariant fromValue(const T &value);

示例代码

QVariant v1(5);
QVariant v2;
v2.setValue(5);
QVariant v3 = QVariant::fromValue(5);int i = v1.toInt();          // i 现在是 5
QString s = v1.toString();   // s 现在是 "5"

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

QVariant::Type 是一个枚举类型，用于表示 QVariant 中封装的数据类型。

// 获取类型，返回的是一个枚举类型，如 QVariant::Int
QVariant::Type QVariant::type() const;// 获取类型名
const char *QVariant::typeName() const;// 根据类型 ID（枚举）获取类型名（字符串）
[static] const char *QVariant::typeToName(int typeId);// 根据类型名（字符串）获取类型 ID（枚举）
[static] QVariant::Type QVariant::nameToType(const char *name);

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

在进行类型转换之前，可以先判断是否能转换成对应的类型：

bool QVariant::canConvert(int targetTypeId) const;
template<typename T>
bool QVariant::canConvert() const;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;// 使用模板函数获取值
template<typename T>
T QVariant::value() const;
// 示例: int i = v.value<int>();

3.2 自定义类型

除了标准类型，自定义的类型也可以使用 QVariant 类进行封装。被 QVariant 存储的数据类型需要有一个默认的构造函数和一个拷贝构造函数。为了实现这一功能，必须使用 Q_DECLARE_METATYPE() 宏。通常会将这个宏放在类的声明所在头文件的下面， 宏的原型为：

Q_DECLARE_METATYPE(Type)

步骤一：定义类型，并注册

// 自定义类型
class Animal
{
public:Animal() {}  // 必须要有默认构造函数Animal(QString name) : _name(name) {}void show() const{qDebug() << "Animal name is:" << _name;}private:QString _name;
};// 自定义类型注册
Q_DECLARE_METATYPE(Animal);

步骤二：使用 fromValue() 存储对象

int main()
{// QVariant vt(Animal("snake")); // 不可以通过构造函数存自定义类型QVariant vt;// 有以下两种方法可以存储自定义类型vt = QVariant::fromValue(Animal("dog")); // 方法一vt.setValue(Animal("cat"));              // 方法二// 如果能转换到 Animal 类型，就进行转换if (vt.canConvert<Animal>()){Animal animal = vt.value<Animal>();animal.show();}return 0;
}

操作涉及的 API 如下：

// 如果当前 QVariant 对象可以转换为对应的模板类型 T，返回 true，否则返回 false
template<typename T>
bool QVariant::canConvert() const;// 将当前 QVariant 对象转换为实际的 T 类型
template<typename T>
T QVariant::value() const;

QVariant 提供了灵活的数据封装和类型转换机制，不仅支持标准类型，还支持自定义类型。详细的 API 和更多的用法可以参考 Qt 官方文档。