Qt 常用数据类型

不是仙人的闲人2024-09-24 21:00

目录

  • [Qt 常用数据类型](#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 字符串的类，提供了丰富的字符串操作功能，如拼接、查找、替换、拆分等。

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

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

    cpp 复制代码 
    QByteArray byteArray = "Hello, QByteArray!";
qDebug() << byteArray.toHex();  // 输出 "48656c6c6f2c205142797465417272617921"

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

    cpp 复制代码 
    QVariant variant = 42;
qDebug() << variant.toString();  // 输出 "42"

1.3 日期和时间

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

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

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

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

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

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

    cpp 复制代码 
    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 坐标。

    cpp 复制代码 
    QPoint point(10, 20);
qDebug() << point;  // 输出 "(10, 20)"

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

    cpp 复制代码 
    QSize size(100, 200);
qDebug() << size;  // 输出 "QSize(100, 200)"

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

    cpp 复制代码 
    QRect rect(10, 20, 100, 200);
qDebug() << rect;  // 输出 "QRect(10, 20, 100, 200)"

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

    cpp 复制代码 
    QLine line(QPoint(0, 0), QPoint(100, 100));
qDebug() << line;  // 输出 "QLine(0, 0, 100, 100)"

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

    cpp 复制代码 
    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 等。

    cpp 复制代码 
    QColor color(Qt::red);
qDebug() << color.name();  // 输出 "#ff0000"

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

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

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

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

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

    cpp 复制代码 
    QFont font("Arial", 12);
qDebug() << font.family();  // 输出 "Arial"

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

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

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

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

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

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

1.6 数据结构

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

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

    cpp 复制代码 
    QList<int> list;
list << 1 << 2 << 3;
qDebug() << list;  // 输出 "(1, 2, 3)"

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

    cpp 复制代码 
    QVector<int> vector;
vector << 1 << 2 << 3;
qDebug() << vector;  // 输出 "(1, 2, 3)"

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

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

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

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

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

    cpp 复制代码 
    QSet<int> set;
set << 1 << 2 << 3 << 2;
qDebug() << set;  // 输出 "{ 1, 2, 3 }"

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

    cpp 复制代码 
    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 类用于读写文件，提供了打开、关闭、读写等文件操作方法。

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

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

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

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

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

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

    cpp 复制代码 
    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 对象，可以通过键值对存储数据。

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

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

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

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

    cpp 复制代码 
    QJsonValue jsonValue("Qt");
qDebug() << jsonValue.toString();  // 输出 "Qt"

1.8 本地化和国际化

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

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

    cpp 复制代码 
    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 客户端。

    cpp 复制代码 
    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 数据报。

    cpp 复制代码 
    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 方法。

    cpp 复制代码 
    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。

    cpp 复制代码 
    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 函数介绍。

构造函数
cpp 复制代码 
// 构造空对象, 里边没有数据
QByteArray::QByteArray();
// 将data中的size个字符进行构造, 得到一个字节数组对象
// 如果 size==-1 函数内部自动计算字符串长度, 计算方式为: strlen(data)
QByteArray::QByteArray(const char *data, int size = -1);
// 构造一个长度为size个字节, 并且每个字节值都为ch的字节数组
QByteArray::QByteArray(int size, char ch);
数据操作
cpp 复制代码 
// 其他重载的同名函数可参考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);
子字符串查找和判断
cpp 复制代码 
// 判断字节数组中是否包含子字符串 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;
遍历
cpp 复制代码 
// 使用迭代器
iterator QByteArray::begin();
iterator QByteArray::end();

// 使用数组的方式进行遍历
// i的取值范围 0 <= i < size()
char QByteArray::at(int i) const;
char QByteArray::operator[](int i) const;
查看字节数
cpp 复制代码 
// 返回字节数组对象中字符的个数
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;
类型转换
cpp 复制代码 
// 将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 的常见用法：

cpp 复制代码 
#include <QCoreApplication>
#include <QDebug>
#include <QByteArray>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 构造函数示例
    QByteArray byteArray1; // 空的 QByteArray
    QByteArray 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 函数介绍。

构造函数
c++ 复制代码 
// 构造一个空字符串对象
QString();
// 将 char* 字符串 转换为 QString 类型
QString(const char *str);
// 将 QByteArray 转换为 QString 类型
QString(const QByteArray &ba);
// 其他重载的同名构造函数可参考Qt帮助文档, 此处略
数据操作
c++ 复制代码 
// 尾部追加数据
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);
子字符串查找和判断
c++ 复制代码 
// 参数 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;
遍历
c++ 复制代码 
// 使用迭代器
iterator  begin();
iterator  end();

// 使用数组的方式进行遍历
const QChar  at(int position) const
const QChar  operator[](int position) const;
查看字节数
c++ 复制代码 
// 返回字节数组对象中字符的个数
int  length() const;
int  size() const;
int  count() const;

// 返回字节串对象中 子字符串 str 出现的次数
// 参数 cs 为是否区分大小写, 默认区分大小写
int  count(const QStringRef &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
类型转换
c++ 复制代码 
// 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() 函数。

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

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

c++ 复制代码 
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"
示例代码
cpp 复制代码 
#include <QCoreApplication>
#include <QDebug>
#include <QString>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 构造函数示例
    QString string1; // 空的 QString
    QString 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 之间的转换
cpp 复制代码 
// 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。

cpp 复制代码 
// QString 转换为 QByteArray

// 转换为本地编码，跟随操作系统
QByteArray QString::toLocal8Bit() const;

// 转换为 Latin-1 编码的字符串（不支持中文）
QByteArray QString::toLatin1() const;

// 转换为 UTF-8 编码格式的字符串（常用）
QByteArray QString::toUtf8() const;
QByteArray 转换为 QString

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

cpp 复制代码 
// 使用 QString 的构造函数进行转换
QString::QString(const QByteArray &ba);
示例代码

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

cpp 复制代码 
#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 转换为 QString
    QByteArray 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 类型。以下展示了一些常用的构造函数：

cpp 复制代码 
// 这类转换需要使用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 对象中：

cpp 复制代码 
// 使用设置函数也可以将支持的类型的数据设置到QVariant对象中
// 这里的 T 类型, 就是QVariant支持的类型
void setValue(const T &value);

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

示例代码

cpp 复制代码 
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 中封装的数据类型。

cpp 复制代码 
// 获取类型，返回的是一个枚举类型，如 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 对象转换为实际的数据类型

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

cpp 复制代码 
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() 宏。通常会将这个宏放在类的声明所在头文件的下面， 宏的原型为：

cpp 复制代码 
Q_DECLARE_METATYPE(Type)
步骤一：定义类型，并注册
cpp 复制代码 
// 自定义类型
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() 存储对象
cpp 复制代码 
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 如下：

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

// 将当前 QVariant 对象转换为实际的 T 类型
template<typename T>
T QVariant::value() const;

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

相关推荐
Kisorge14 分钟前
【C语言】指针数组、数组指针、函数指针、指针函数、函数指针数组、回调函数
c语言·开发语言
轻口味1 小时前
命名空间与模块化概述
开发语言·前端·javascript
晓纪同学2 小时前
QT-简单视觉框架代码
开发语言·qt
威桑2 小时前
Qt SizePolicy详解：minimum 与 minimumExpanding 的区别
开发语言·qt·扩张策略
飞飞-躺着更舒服2 小时前
【QT】实现电子飞行显示器（简易版）
开发语言·qt
fyzy2 小时前
Qt获取本地计算的CPU温度
qt
cbdg37572 小时前
Qt 6 QML Settings location 不创建指定路径文件
qt
了一li2 小时前
Qt中的QProcess与Boost.Interprocess：实现多进程编程
服务器·数据库·qt
杨德杰2 小时前
QT网络（一）：主机信息查询
网络·qt
明月看潮生2 小时前
青少年编程与数学 02-004 Go语言Web编程 16课题、并发编程
开发语言·青少年编程·并发编程·编程与数学·goweb
热门推荐
01Cube-Studio：开源大模型全链路一站式中台02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07构建高效的广告投放系统：应用架构的设计与实现08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10【一文读懂】NTN（非地面网络）技术介绍