Qt-常用数据类型
常用基本数据类型
| 类型名称 | 注释 | 备注 |
|---|---|---|
| qint8 | signed char | 有符号8位数据类型 |
| qint16 | signed short | 有符号16位数据类型 |
| qint32 | signed int | 有符号32位数据类型 |
| qint64 | long long int（或__int64） | 有符号64位数据类型 |
| qintptr | qint32 或 qint64 | 指针类型，用于带符号整型。 （32位系统为qint32、64位系统为qint64） |
| qlonglong | long long int 或(__int64) | 和qint64定义一样 |
| qptrdiff | qint32 或 qint64 | 表示指针差异的整型。32位系统为qint32、64位系统为qint64 |
| qreal | double | 除非配置了-qreal float选项，否则默认为double |
| quint8 | unsigned char | 无符号8位数据类型 |
| quint16 | unsigned short | 无符号16位数据类型 |
| quint32 | unsigned int | 无符号32位数据类型 |
| quint64 | unsigned long long int 或 (unsigned __int64) | 无符号64位数据类型，Windows中定义为unsigned __int64 |
| quintptr | quint32 或 quint64 | 指针类型，用于无符号整型。32位系统为quint32、64位系统为quint64 |
| qulonglong | unsigned long long int 或 (unsigned __int64) | 和quint64定义一样 |
| uchar | unsigned char | 无符号字符类型 |
| uint | unsigned int | 无符号整型 |
| ulong | unsigned long | 无符号长整型 |
| ushort | unsigned short | 无符号短整型 |
QByteArray
QByteArray提供了一个【字节】数组，既可以储存原始字节（包括‘\0’），又可以储存惯例上8位以’\0’结尾的字符串（字符数组）。
Qt中的QByteArray储存的十六进制数是0xFF，实际是以ASCII码储存的，储存形式为‘\xFF’，所以如果需要比较的话，需要用array.at(0)=='\xff’表示，而不是array.at(0)==0xFF。
构造函数
一种初始化QByteArray方式是给他的构造函数传入一个const char*即可，此时执行了深度拷贝。
如果出于效率问题不想进行深度拷贝，则使用QByteArray::fromRawData(const char * data, int size)。返回的对象直接和数据指针产生关联。注意：通过这种方式创建时，不包含尾随的终止符，QByteArray不会自动添加，除非通过深度拷贝。
访问和赋值
访问QByteArray主要有4中方式，分别为[]、at()、data[]和constData[]。其中[]和data[]为可读可写，at()和constData[]仅为可读。如果仅是读，则通过at()和constData[]访问速度最快，因可避免复制处理。示例如下：
QByteArray ba;
ba.resize(6);
ba[0] = 0x3c;
ba[1] = 0xb8;
ba[2] = 0x64;
ba[3] = 0x18;
ba[4] = 0xca;
ba.data()[5] = 0x31;
qDebug()<<"[]"<一次取出多个字符
- QByteArray QByteArray::left(int len) const：从最左边开始取出len长度的字符
- QByteArray QByteArray::right(int len) const：从最右边开始取出len长度的字符
- QByteArray QByteArray::mid(int pos, int len = -1) const：从pos开始，返回指定长度的数组，如果len=-1（默认）或者pos+len>size()，则返回从指定pos开始到数组尾的所有字节。
获取数据指针
- char* QByteArray::data() /* return a pointer to the data stored in the byte array */
- const char* QByteArray::constData() const /* return a pointer to the data stored in the byte array */
通过data()或者constData()可以获取QByteArray的真实数据指针。
修改字节的方法
QByteArray提供了很多修改字节的方法：append()、prepend()、insert()、replace()、remove()。
hex转换
把Hex编码转换为char存储到QByteArray：
QByteArray text = QByteArray::fromHex("517420697320677265617421");
text.data();
// returns "Qt is great!"
把QByteArray转为Hex编码：
QByteArray ba;
ba.resize(3);
ba[0] = 0x30;
ba[1] = 0x31;
ba[2] = 0x32;
qDebug() << ba.toHex(); //return "303132"
数值转换与输出
尽管QByteArray是一个集合，但也可以作为一个特殊形式的数值用，其灵活的转换格式，可大大方便各种格式数据转换与显示的需求。如显示二进制和十六进制、显示科学计数和指定小数位的数值。示例如下：
把单个字符转为2-36进制数据格式：
int n = 63;
qDebug()<按照指定进制格式直接复制，其中n可以是各类常见数值类型：
QByteArray ba;
int n = 63;
ba.setNum(n); // ba == "63"
ba.setNum(n, 16); // ba == "3f"
把数值按指定格式和小数位转换输出，小数位四舍五入：
QByteArray ba1 = QByteArray::number(12.3456, 'E', 3);
QByteArray ba2 = QByteArray::number(12.3456, 'f', 3);
qDebug()<字符串数值转换为各类数值
QByteArray若为数值，可通过to**方法转为各种类型数据，示例如下：
QByteArray strInt("1234");
bool ok0;
qDebug() << strInt.toInt(); // return 1234
qDebug() << strInt.toInt(&ok0,16); // return 4660, 默认把strInt作为16进制的1234，对应十进制数值为4660
QByteArray string("1234.56"); bool ok1; qDebug() << string.toInt(); // return 0, 小数均视为0
qDebug() << string.toInt(&ok1,16); // return 0, 小数均视为0
qDebug() << string.toFloat(); // return 1234.56
qDebug() << string.toDouble(); // return 1234.56
QByteArray str("FF");
bool ok2;
qDebug() << str.toInt(&ok2, 16); // return 255, ok2 == true
qDebug() << str.toInt(&ok2, 10); // return 0, ok == false, 转为十进制失败
大小写转换
QByteArray若为带大小写的字符串，可通过toUpper()和toLower()方法实现大小写转换，示例如下：
QByteArray x("Qt by THE QT COMPANY");
QByteArray y = x.toLower(); // y == "qt by the qt company"
QByteArray z = x.toUpper(); // z == "QT BY THE QT COMPANY"
与字符串互转
QByteArray与QString互转极为简单，二者从本质上类似，都是连续存储，区别是前者可以存无法显示的字符，后者只存可显示的字符。如QByteArray可以存0x00-0x19，而QString则存储如0x30等可显示字符（0x20-0x7E）。可显示字符可参见ASCII表。
字符型
QByteArray转为QString示例：
QByteArray ba("abc123"); QString str = ba; //或str.prepend(ba); qDebug()<QString转为QByteArray示例：
QString str("abc123"); QByteArray ba = str.toLatin1(); qDebug()<数组型
QByteArray数组转为QString字符串，中间加入空格：
log.append(serialPort->recvDataArray->toHex(' ')); qDebug() << log.toUpper();
QString字符串转为QByteArray数组，中间去掉空格：
QString text = tEditSource->toPlainText().remove(QRegExp("\\s"));
QByteArray array; ok;
arrasize(text.length() / 2);
for (int 0; i < text.count();) {
ardata() = (uint8_t)text.mid(i, 2).toInt(&ok, 16);
i += 2;
}
与自定义结构体之间的转换
结构体转QByteArray
SHT30RecvBufferTypedef sendBuffer;
sendBuffer.tempH = 0x01;
sendBuffer.tempL = 0x02;
sendBuffer.tempCRC = 0x03;
sendBuffer.humiH = 0x04;
sendBuffer.humiL = 0x05;
sendBuffer.humiCRC = 0x06;
QByteArray sendByte;
sendByte.append((char*)&sendBuffer, sizeof(sendBuffer));
QByteArray转结构体
SHT30RecvBufferTypedef *SHT30RecvBuffer = (SHT30RecvBufferTypedef*)buf.data();
拼接2个QByteArray
QByteArray x("free");
QByteArray y("dom");
x.append(y);
// x == "freedom"
截取部分字节组成新的QByteArray
可以调用mid函数，从哪个pos开始截取，截取的长度是多少。
QByteArray x("Five pineapples");
QByteArray y = x.mid(5, 4);
// y == "pine" QByteArray z = x.mid(5);
// z == "pineapples"
带空格字符串转hex
void String2Hex(QString str, QByteArray *sendData) {
QString str1 = str.trimmed();
sendData->resize((str1.length() + 1) / 3);
int index = 0;
bool ok;
for (int i = 0; i < str1.length();)
{
sendData->data()[index] = str1.mid(i , 2).toInt(&ok, 16);
index++;
i += 3;
}
}
QBuffer
QBuffer类是一个操作QByteArray的输入、输出设备的接口。
构造函数：QBuffer(QByteArray *byteArray, QObject *parent = 0)
QBuffer类用来读写内存缓存。在使用之前需open()来打开缓存并设置模式（只读、只写等）。
QDataStream和QTextStream也可以使用一个QByteArray参数来构造，这些构造函数创建并且打开一个内部的QBuffer。
QDataStream(QByteArray *a, QIODevice::OpenMode mode)
QTextStream(QByteArray *a, QIODevice::OpenMode mode = QIODevice::ReadWrite)
QdataStream(QByteArray *a, QIODevice::OpenMode mode)
QVector
QVector是Qt对所有数组的封装。
比如定义一个int类型的数组，原先可以int array[10]，在Qt中可以QVector array(10)，赋值时依然可以array[5] = 4，读取时也可以a = array[9]。和原先的用法一致。
QVector的好处：
- 可以用count()函数获取数组的大小，方便遍历。（普通数组必须先预定义好数组大小，虽然QVector最好也要预定义大小，但是也可以不预定义）
- 可以用append()函数或者<<操作符，来往数组最后添加元素而不用担心溢出问题。
使用
添加头文件
#include 构造
QVector<int> vector;
for(int i = 0; i < 10; ++i) vector << i + 1;
//构造
QVector<int> myVector1(5); //开辟5个大小的空间
QVector<int> myVector2(5,1); //5个值，都是1
QVector<int> myVector3(vector); //用另一个QVector初始化
添加
QVector<QString> strArray;
strArray.append("Hello");
strArray << "world"; strArray << "MyName" << "is" << "LEO";
/* 现在strArray总共有5个元素，strArray.count() == 5 */
QVector<int> myVector;
myVector.push_back(5); //在数组后添加元素
myVector.push_front(4); //在数组首位置添加元素
myVector.prepend(3); //在数组首位置添加元素
myVector.append(6); //在数组最后添加元素
myVector << 7; //在数组最后添加元素
myVector.insert(0,2); //在数组位置0，添加元素
myVector.insert(0,2,1); //在数组位置0，添加2个值为1的元素
myVector.insert(myVector.end(),8); //在数组最后，添加元素
myVector.insert(myVector.end(),2,9); //在数组最后，添加2个值为9的元素
qDebug() << myVector;
删除
//删除
myVector.clear();
myVector << vector;
myVector.remove(0,2); //从位置0开始，移除2个元素
myVector.remove(0); //移除位置0的元素
qDebug() << myVector;
myVector.pop_back(); //移除最后一个元素
myVector.pop_front(); //移除第一个元素
myVector.clear();
myVector << vector;
myVector.erase(myVector.begin());//移除某位置的元素
myVector.erase(myVector.begin(),myVector.end());//移除区间所有元素
qDebug() << myVector;
改
//改
myVector.clear();
myVector << vector;
myVector.replace(0,10);//位置0上的元素，用10来代替
qDebug() << myVector;
查找
qDebug() << myVector.indexOf(2,0);//从位置0开始，查找元素2，返回下标
qDebug() << myVector.lastIndexOf(2,1);//从右向左数，位置0开始查找元素2，返回下标
qDebug() << myVector.startsWith(2);//判断，第一个元素是否是2
qDebug() << myVector.endsWith(2);//判断，最后一个元素是否是2
取值
qDebug() << myVector.front(); //第一个元素
qDebug() << myVector.first(); //第一个元素
qDebug() << myVector.last(); //最后一个元素
qDebug() << myVector.mid(1,3); //取位置1后，3个元素
遍历
QVector<QString>::iterator iter;
for (iter = strArray.begin(); iter != strArray.end(); iter++) {
qDebug() << *iter << "\0";
}
转换
//将QVector转为stdVector
std::vector<int> stdVector = myVector.toStdVector();
//将QVector转为QList
QList<int> list = myVector.toList();
qDebug() << list;
//将stdVector转为QVector
myVector.clear();
myVector = QVector<int>::fromStdVector(stdVector);
qDebug() << myVector;
//将QList转为QVector
myVector.clear();
myVector = QVector<int>::fromList(list);
qDebug() << myVector;
取代
/* 元素位置1被替代 */
strArray.replace(1, "LEO");
其他
myVector.squeeze(); //释放不需要存储项的内存
qDebug() << myVector.data(); //首地址
qDebug() << myVector.capacity(); //内存大小
myVector.clear(); //清空内存
在上述这些函数中，除了append和replace这两个函数外，其他函数会比较慢。因为其他函数在内存中移动一个位置时，会使向量容器内的对象移动多次。如果想要一个能在中间快速插入和删除元素的容器时，可以使用QList或QLinkedList。
调用at()函数来读取对象时，会比调用operator()函数读取速度更快，因为不会使用深度复制（deep copy）。
调用data()函数可以访问保存在QVector的数据，这个函数会返回指向向量容器的第一个对象的指针。可以使用该指针访问和修改向量容器内的对象。可以使用指针将向量容器传递给接收的普通C++数组的函数。
contains()函数用来查找向量容器内是否包含某个对象。
count(“对象”)函数可以找出某个对象在向量容器中出现的次数。
resize()函数可以在任何时候改变QVector向量容器的体积。如果新的向量容器体积比之前的大，QVector也许会重新分配整个向量容器。QVector会预先分配2倍于实际数据大小的空间，从而减少再分配次数。
reserve()函数，如果事先知道向量容器大概包含多少个对象，可以使用这个函数来预先分配好一定的内存大小。
capacity()函数返回改向量容器所占的内存的实际大小空间。
QString
Qt中提供了QString类来储存字符串，大部分情况下，我们都是在使用QString。
QString储存了16位的unicode码，很容易储存非ASCII码或者非Lantin1编码，另外QString在所有Qt API中都是通用的。
其他类型转换为QString
原始转换
QString data = QString("%1").arg(num);
上面这样写法会保留全部小数，如果要保留指定小数位
QString::number(tempHumiValueTable[0]->getTemp(),'f',1)
QString::number函数转换
QString::number是将数数字（整数、浮点数、有符号、无符号等）转换为QString类型，常用于UI数据显示。查看API接口，number提供如下几种类型的转换，适合各种场合调用。
static QString number(int, int base=10);
static QString number(uint, int base=10);
static QString number(long, int base=10);
static QString number(ulong, int base=10);
static QString number(qlonglong, int base=10);
static QString number(qulonglong, int base=10);
static QString number(double, char f='g', int prec=6);
第一个参数：待转换数字
第二个参数（整型）：转换进制
第二个参数（浮点数）：浮点数格式
第三个参数（浮点数）：保留小数位数
默认情况下是十进制显示方式转换，也可以使用八进制、十六进制显示方式调用。
QString::number 整数转换
int a = 20;
uint b =255;
QString::number(a); /* 20 */
QString::number(a,10); /* 20 */
QString::number(b); /* 255 */
QString::number(b,16); /* ff */
QString::number 浮点数转换
1)保留2位小数
float a = 1.234;
QString::number(a,'f', 2); /* 1.23 */
float a = 1;
QString::number(a,'f', 2); /* 1.00 */
保留2位有效数字，以简单方式表示，或者科学计数法表示
float a = 0.00001;
QString::number(a, 'g', 2); /* 1e-5 */
float a = 0.00012;
QString::number(a, 'g', 2); /* 1.2e-4 */
保留指定位数（如001）
整数转换为字符串，并保留3位，不足在前面补0，这一块其实属于“sprintf”格式函数的范畴：
int a=1;
QString str=QString::number(a).sprintf("%03d",a);
//或者
/* a:要转换的值，3：转换结果的数据位数，10：十进制（16进制对应16），空缺补充的字节 */
QString str=QString("%1").arg(a, 3, 10, QChar('0'));
QString转换为其他类型
QString转换为float
QString data; float num = data.toFloat();
判断2个QString相等
QString str = QString::fromLocal8Bit("球形");
if(str.compare(QString::fromLocal8Bit("球形") == 0)
{ }
或者：
if(str ==QString::fromLocal8Bit("球形"))
{ }
与十六进制数相互转换
QString转int
QString hexstr = "0xFF";
bool ok;
int hexnum = hexstr.toInt(&ok,16); // 表示以16进制方式读取字符串 qDebug()<int转十六进制字符串
int hexnum = 255;
QString hexstr = QString::number(hexnum,16);
//表示转换成16进制存入字符串 qDebug()<QString中，涉及到类型转换的函数如下：
short toShort(bool *ok=nullptr, int base=10) const;
ushort toUShort(bool *ok=nullptr, int base=10) const;
int toInt(bool *ok=nullptr, int base=10) const;
uint toUInt(bool *ok=nullptr, int base=10) const;
long toLong(bool *ok=nullptr, int base=10) const;
ulong toULong(bool *ok=nullptr, int base=10) const;
qlonglong toLongLong(bool *ok=nullptr, int base=10) const;
qulonglong toULongLong(bool *ok=nullptr, int base=10) const;
float toFloat(bool *ok=nullptr) const;
double toDouble(bool *ok=nullptr) const;
以及
static QString number(int, int base=10);
static QString number(uint, int base=10);
static QString number(long, int base=10);
static QString number(ulong, int base=10);
static QString number(qlonglong, int base=10);
static QString number(qulonglong, int base=10);
static QString number(double, char f='g', int prec=6);
其中的base便是设置转换方式以n进制为标准，默认为10进制。
转换为16进制和2进制等字符串，并自动填0
函数原型
QString arg(int a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char( ' ' )) const;
QString arg(uint a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char( ' ' )) const;
QString arg(long a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char( ' ' )) const;
QString arg(ulong a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char( ' ' )) const;
QString arg(qlonglong a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char( ' ' )) const;
QString arg(qulonglong a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char( ' ' )) const;
QString arg(short a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char( ' ' )) const;
QString arg(ushort a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char( ' ' )) const;
QString arg(QChar a, int fieldWidth = 0, QChar fillChar = QLatin1Char( ' ' )) const;
QString arg(char a, int fieldWidth = 0, QChar fillChar = QLatin1Char( ' ' )) const;
QString arg(double a, int fieldWidth = 0, char format = 'g', int precision = -1, QChar fillChar = QLatin1Char( ' ' )) const
实例
typedef unsigned char uint8;
QString strShowHex,strShowBin;
uint8 val = 0xfc;
//16进制 strShowHex = QString("0x%1").arg(int(val), 4, 16, QLatin1Char('0'));
//显示结果为： 0x00fc
//2进制
strShowBin = QString("%1 b").arg(int(val), 8, 2, QLatin1Char('0'));
//显示结果为： 11111100 b
字串追加
把str添加到字符串中并且返回结果的引用。
函数原型
QString & QString::append(const QString & str)
例子
QString string = "Test"; string.append( "ing" ); // string == "Testing"
字符串占位
原型
QString QString::arg(const QString & a, int fieldwidth = 0) const
这个函数将返回使用a来替换最低层出现的%i（i为’1’或’2’或……‘9’）的字符串。
fieldwidth值指定了填充到a中的最小空间。正值将产生右对齐文本，负值将产生左对齐文本。
QString firstName( "liu" );
QString lastName( "yong" );
QString fullName;
fullName = QString( "First name is '%1', last name is '%2'" ).arg( firstName ).arg( lastName ); // fullName == First name is 'liu', last name is 'yong'
字符串索引
原型
QChar QString::at(uint i) const
返回在索引i处的字符，或者如果i超过字符串的长度返回0。
const QString string( "abcdefgh" ); QChar ch = string.at( 4 ); // ch == 'e'
判断是否含有某个字符串
#include
QString strl="iloveyou";
str.contains("you",Qt::CaseSensitive); //成功返回true 第二个参数表示是否大小写敏感
与QDateTime互转
QDateTime转为QString
QString strBuffer;
QDateTime time;
time = QDateTime::currentDateTime();
strBuffer = time.toString("yyyy-MM-dd hh:mm:ss");
// strBuffer = 2018-06-06 14:05:00
QString转为QDateTime
QString strBuffer;
QDateTime time; strBuffer = "2018-06-06 14:05:00";
time = QDateTime::fromString(strBuffer, "yyyy-MM-dd hh:mm:ss");
QVariant
参考https://blog.csdn.net/xiaopei_yan/article/details/81410092
QVariant是一个很神奇、很方便的类。很多时候需要传递几种不同类型的数据，如果用结构体又不太方便，容器保存的也只是一种数据类型，QVariant则可以搞定。
QVariant充当着最常见的数据类型的联合，QVariant可以保存很多Qt的数据类型，包括QBrush、QColor、QCursor、QDateTime、QFont、QKeySequence、QPalette、QPen、QPixmap、QPoint、QRect、QRegion、QSize、QString，并且还与C++的基本类型，如int、float等。
QVariant支持自定义数据类型。被QVariant储存的数据类型，需要有一个默认的构造函数和一个拷贝的构造函数。
为了实现这个功能，通常要先调用**Q_DECLARE_METATYPE()**这个宏，将其放在类的声明所在的头文件下面：
Q_DECLARE_METATYPE(MyClass)
QVariant的思路和集装箱一致，屏蔽了不同类型的数据结构之间的差异性，让数据以一种标准的形式在类之间、函数之间、对象之间传递，就像集装箱在不同的国家之间运输一样。
对于支持的类型
可直接赋值，但是取值时，对存入的是什么类型，取出也要为这个类型。
如存入为int类型，输出为toString()。
QVariant var;var.setValue(12);int data=var.toInt();
或
QVariant var=12;int data=var.toInt();
对于不支持的类型
如自定义的结构体。由于Qt都是基于元对象系统，故在头文件里要注册此类属于元类型。
储存用到了QVariant QVariant::fromValue(const T &value) 或 void QVariant::setValue(const T &value)
获取用到了T QVariant::value() const
在此之前一般要用bool QVariant::canConvert(int targetTypeId) const判断是否可以转换。
例
.h文件声明
struct MyClass{
int id;
QString name;
};
Q_DECLARE_METATYPE(MyClass)
.cpp文件
//存储数据
MyClass myClass;
myClass.id=0;
myClass.name=QString("LiMing");
data[0]=QString("ddd");
data[1]=123;
data[3]=QVariant::fromValue(myClass); //获取数据
QString str=data.value(0).toString();
int val=data.value(1).toInt();
if(data[3].canConvert())
{
MyClass myClass=data[3].value();
int id=myClass.id;
QString name=myClass.name;
}
保存指针
//保存
QVariant var=QVariant::fromValue((void*)event);
//获取
QPaintEvent* e=(QPaintEvent*)var.value();
时间类
QDateTime
将当前时间转换为QString类型
QDateTime dateTime;
QString strDateTime = dateTime.currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
从字符串转换为毫秒（需完整的年月日时分秒）
datetime.fromString("2018-07-18 12:10:10:111", "yyyy-MM-dd- hh:mm:ss.zzz").toMSecsSinceEpoch();
从字符串转换为秒（需完整的年月日时分秒）
datetime.fromString("2018-07-18 12:10:10:111", "yyyy-MM-dd hh:mm:ss.zzz").toTime_t();
从毫秒转换到年月日时分秒
datetime.fromMSecsSinceEpoch(1315193829218).toString("yyyy-MM-dd hh:mm:ss.zzz");
从秒转换到年月日时分秒（若有zzz，则为000）
datetime.fromTime_t(1315193829).toString("yyyy-MM-dd hh:mm:ss[:zzz]");
求两个时间毫秒差
QTime startTime = QTime::currentTime();
QTime stopTime = QTime::currentTime();
qint64 temp = startTime.msecsTo(stopTime);
获取毫秒级的时间戳
QDateTime dateTime = QDateTime::currentDateTime();
// 字符串格式化
QString timestamp = dateTime.toString(“yyyy-MM-dd hh:mm:ss.zzz”);
// 获取毫秒值
int ms = dateTime.time().msec();
// 转换成时间戳
qint64 epochTime = dateTime.toMSecsSinceEpoch();