不是仙人的闲人

不是仙人的闲人

关注
发信
关注(28)粉丝(399)

Qt 常用数据类型

目录

Qt 常用数据类型

1. 基础类型

1. 1 基础数据类型

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

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

详细说明
  • 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: 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: 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: 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: 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: 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: 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 locale(QLocale::English, QLocale::UnitedStates);
qDebug() << locale.toString(QDate::currentDate());  // 输出 "MM/dd/yyyy" 格式的日期

1.9 网络编程和 URL

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

详细说明

  • 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. 字符串类型

2.1 QByteArray

构造函数
// 构造空对象, 里边没有数据
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; // 空的 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();
// 将 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; // 空的 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 之间的转换
// 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 转换为 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

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 官方文档。

09-21 05:22
Powered by LMLPHP ©2024 不是仙人的闲人 0.002350