Qt-常用数据类型

2023-10-30

常用基本数据类型

类型名称	注释	备注
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()<<"[]"<<ba[2]; //[] d 
qDebug()<<"at()"<<ba.at(2); //at() d 
qDebug()<<"data()"<<ba.data()[2]; //data() d 
qDebug()<<"constData()"<<ba.constData()[2]; //constData() d 
qDebug()<<"constData()"<<ba.constData()[5]; //constData() 1

一次取出多个字符

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()<<QByteArray::number(n);        
// returns "63" 
qDebug()<<QByteArray::number(n, 16);      
// returns "3f" 
qDebug()<<QByteArray::number(n, 16).toUpper();  
// returns "3F" 
qDebug()<<QByteArray::number(n, 2);      
// returns "111111" 
qDebug()<<QByteArray::number(n, 8);      
// returns "77"

按照指定进制格式直接复制，其中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()<<ba1; // returns "1.235E+01" 
qDebug()<<ba2;  // returns "12.346"

字符串数值转换为各类数值

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()<<str ; //输出："abc123"

QString转为QByteArray示例：

QString str("abc123"); QByteArray ba = str.toLatin1(); qDebug()<<ba; //输出："abc123"

数组型

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>

构造

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()<<hexnum<<<endl;  
/* 输出255 */

int转十六进制字符串

int hexnum = 255; 
QString hexstr = QString::number(hexnum,16);
//表示转换成16进制存入字符串 qDebug()<<hexstr<<endl;		
/* 输出FF */

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> 
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 myClass=data[3].value<MyClass>();        
	int id=myClass.id;        
	QString name=myClass.name;    
}

保存指针

//保存
QVariant var=QVariant::fromValue((void*)event);
//获取
QPaintEvent* e=(QPaintEvent*)var.value<void*>();

时间类

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();

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)