您的位置:首页 > 娱乐 > 明星 > 租远程服务器_购买seo关键词排名优化官网_站长之家爱站网_网页设计制作网站模板

租远程服务器_购买seo关键词排名优化官网_站长之家爱站网_网页设计制作网站模板

2024/12/23 10:11:50 来源:https://blog.csdn.net/qq_68194402/article/details/142375893  浏览:    关键词:租远程服务器_购买seo关键词排名优化官网_站长之家爱站网_网页设计制作网站模板
租远程服务器_购买seo关键词排名优化官网_站长之家爱站网_网页设计制作网站模板

目录

  • Qt 常用数据类型
    • 1. 基础类型
      • 1. 1 基础数据类型
        • 详细说明
      • 1.2 字符串和文本处理
      • 详细说明
      • 1.3 日期和时间
        • 详细说明
      • 1.4 数学和几何
        • 详细说明
      • 1.5 颜色和图形
        • 详细说明
      • 1.6 数据结构
        • 详细说明
      • 1.7 文件 IO 操作和 JSON 解析
        • 详细说明
      • 1.8 本地化和国际化
        • 详细说明
      • 1.9 网络编程和 URL
        • 详细说明
    • 2. 字符串类型
      • 2.1 QByteArray
        • 构造函数
        • 数据操作
        • 子字符串查找和判断
        • 遍历
        • 查看字节数
        • 类型转换
        • 示例代码
      • 2.2 QString
        • 构造函数
        • 数据操作
        • 子字符串查找和判断
        • 遍历
        • 查看字节数
        • 类型转换
        • 字符串格式化
        • 示例代码
      • 2.3 不同字符串类型相互转换
        • std::string 与 QString 之间的转换
        • QString 与 QByteArray 之间的转换
        • QByteArray 转换为 QString
        • 示例代码
    • 3. QVariant
      • 3.1 标准类型
        • 将标准类型转换为 QVariant 类型
        • 判断 QVariant 中封装的实际数据类型
        • 将 QVariant 对象转换为实际的数据类型
      • 3.2 自定义类型
        • 步骤一:定义类型,并注册
        • 步骤二:使用 fromValue() 存储对象

Qt 常用数据类型

1. 基础类型

1. 1 基础数据类型

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

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

类型名称注释说明
qint8signed char有符号8位数据类型,表示范围为 -2⁷ 到 2⁷-1
qint16signed short有符号16位数据类型,表示范围为 -2¹⁵ 到 2¹⁵-1
qint32signed int有符号32位数据类型,表示范围为 -2³¹ 到 2³¹-1
qint64long long int 或 (__int64)64位有符号数据类型,Windows中定义为__int64,表示范围为 -2⁶³ 到 2⁶³-1
qintptrqint32 或 qint64指针类型,根据系统类型不同而不同,32位系统为qint32、64位系统为qint64,用于存储指针值
qlonglonglong long int 或(__int64)64位有符号数据类型,Windows中定义为__int64,与qint64相同
qptrdiffqint32 或 qint64根据系统类型不同而不同,32位系统为qint32、64位系统为qint64,用于表示指针差值
qrealdouble 或 float浮点数类型,除非配置了-qreal float选项,否则默认为double
quint8unsigned char无符号8位数据类型,表示范围为 0 到 2⁸-1
quint16unsigned short无符号16位数据类型,表示范围为 0 到 2¹⁶-1
quint32unsigned int无符号32位数据类型,表示范围为 0 到 2³²-1
quint64unsigned long long int 或 (unsigned __int64)无符号64位数据类型,Windows中定义为unsigned __int64,表示范围为 0 到 2⁶⁴-1
quintptrquint32 或 quint64指针类型,根据系统类型不同而不同,32位系统为quint32、64位系统为quint64,用于存储无符号指针值
qulonglongunsigned long long int 或 (unsigned __int64)无符号64位数据类型,Windows中定义为unsigned __int64,与quint64相同
ucharunsigned char无符号字符类型,表示范围为 0 到 2⁸-1
uintunsigned int无符号整型,表示范围为 0 到 2³²-1
ulongunsigned long无符号长整型,表示范围依赖于平台,在32位系统上通常为 0 到 2³²-1,在64位系统上通常为 0 到 2⁶⁴-1
ushortunsigned short无符号短整型,表示范围为 0 到 2¹⁶-1
qsizetypesize_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文件信息类用于获取文件的元数据。
QJsonDocumentJSON 文档类用于解析和生成 JSON 文档。
QJsonObjectJSON 对象类用于表示和操作 JSON 对象。
QJsonArrayJSON 数组类用于表示和操作 JSON 数组。
QJsonValueJSON 值类用于表示和操作 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 通信、网络服务等。

类型名称注释说明
QTcpSocketTCP 套接字类用于 TCP 网络通信。
QUdpSocketUDP 套接字类用于 UDP 网络通信。
QNetworkAccessManager网络访问管理器类用于发送 HTTP 请求。
QUrlURL 类用于处理 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::stringQStringQStringQByteArray 之间的相互转换。详细的 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 官方文档。

版权声明:

本网仅为发布的内容提供存储空间,不对发表、转载的内容提供任何形式的保证。凡本网注明“来源:XXX网络”的作品,均转载自其它媒体,著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处。

我们尊重并感谢每一位作者,均已注明文章来源和作者。如因作品内容、版权或其它问题,请及时与我们联系,联系邮箱:809451989@qq.com,投稿邮箱:809451989@qq.com