Qt --- 基本类

qiuqiuyaq

已于 2022-06-06 14:25:01 修改

阅读量4k

点赞数 6

分类专栏： Qt 文章标签： qt 开发语言 c++

于 2022-03-06 14:13:08 首次发布

本文链接：https://blog.csdn.net/weixin_60569662/article/details/123244650

版权

Qt 专栏收录该内容

7 篇文章 16 订阅

订阅专栏

基础类型

因为Qt是一个C++框架, 因此C++中所有的语法和数据类型在Qt中都是被支持的, 但是Qt中也定义了一些属于自己的数据类型(大部分是c++数据类型的别名), 下面给大家介绍一下这些基础的数据类型

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

类型名称	注释	备注
qint8	signed char	有符号8位数据
qint16	signed short	16位数据类型
qint32	signed short	32位有符号数据类型
qint64	long long int 或(__int64)	64位有符号数据类型，Windows中定义为__int64
qintptr	qint32 或 qint64	指针类型根据系统类型不同而不同，32位系统为qint32、64位系统为qint64
qlonglong	long long int 或(__int64)	Windows中定义为__int64
qptrdiff	qint32 或 qint64	根据系统类型不同而不同，32位系统为qint32、64位系统为qint64
qreal	double 或 float	除非配置了-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)	Windows中定义为__int64
uchar	unsigned char	无符号字符类型
uint	unsigned int	无符号整型
ulong	unsigned long	无符号长整型
ushort	unsigned short	无符号短整型
qsizetype	size_t

解析：

q：Qt

int：整型

8：代表整型占8个位，8个位 == 1字节的整型，位数 / 8 == 字节数，有符号的8位数据：-128~127

不同平台有不同的规则，保证了在不同平台中一定有32位 int，64位int...没有规定 int 必须是4个字节，只是规定了关系：short<= int <= long，int 不一定是4个字节，为了能够跨平台，封装了qint8、qint16...等数据类型

ptr：标识数组的位置，可以指针或者下标指向它的位置

real：实数 || 小数，double 或者 float

u：无符号

qsizetype：大小的类型，大小没有负数，别名size_t：unsigned long类型

打开独立的帮助文档程序查看 assistant 查找 QtGlobal

log输出 - - - 日志输出

在Qt中进行log输出, 一般不使用C中的printf, 也不是使用C++中的cout, Qt框架提供了专门用于日志输出的类, 头文件名为 QDebug

选择编译套件(用Qt Creator开发请选择MinGW Minimalist GNU for Windows)

CMakeLists.txt CMake的工程文件和 qMake 不同

cmake_minimum_required(VERSION 3.5)

project(untitled LANGUAGES CXX)

set(CMAKE_INCLUDE_CURRENT_DIR ON)

set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)

set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(Qt5Core)

add_executable(untitled
  main.cpp
)
target_link_libraries(untitled Qt5::Core)

main.cpp

#include<QCoreApplication>    //不带ui界面Core核心 QApplication带ui界面 应用程序类
#include<iostream>
#include<QDebug>              //用来输出日志消息的头文件
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    //不推荐使用C/C++的输出但是可以使用
    printf("hello QT\n");
    std::cout<<"hello Qt2"<<std::endl;
    /*错误使用
    QDebug q;               no matching constructor for initialization of 'QDebug'  没有匹配的构造函数              
    q<<"hello debug"<<endl; use of undeclared identifier 'end' */

    //Qt中提供了专门的输出方法
    qDebug()<<"hello debug";//qDebug()不是类名
    qWarning()<<"warining";
    qInfo()<<"info";
    qCritical<<""critical;
    qFatal()<<"fatal";      //too few arguments to funtion call,at least argument 'msg' m... 遇到会直接中断程序不能用流的方式输出致命错误
    qDebug()<<"maye"<<"is"<<"good"; //每个输出中间自动加空格 结尾自动换行[去不掉]
    return a.exec();
}
/*输出*/
hello Qt
hello Qt2
hello debug
warining
info
critical
maye is good

匿名函数转到定义：Follow Symbol Under Cursor

基本分类

qDebug：调试信息提示
qInfo ：输出信息
qWarning ：一般的警告提示
qCritical ：严重的错误提示
qFatal ：致命错误提示，会直接中断程序

C风格输出类似printf( )

qDebug("debug %d %s",50,"hello"); 
qWarning("warning %d",12);
qInfo("info %d",34);
qCritical("critical %d",89);
qFatal("fatal %s","hello");	 //致命错误会直接中断程序--->程序异常结束
qDebug()<<"dfs";

/*输出*/

debug 50 hello
warning 12
info 34
critical 89
fatal hello                 //能这样输出,但是执行到这行代码时,程序会直接中断
程序异常结束

C++风格

qDebug()<<"好帅"<<endl;
qInfo()<<"qInfo"<<endl;
qWarning()<<"qWarnning"<<endl;
qCritical()<<"qCritical"<<endl;
#qFatal()<<"qFatal"<<endl;			//致命错误不能用<<输出

字符串类型

C语言=> char* (char数组也是char*类型)存储字符串

C++ => std::string存储字符串

Qt => QByteArray(字节数组当作c语言的char*,只是对字符的简单封装不带编码),QString(Qt中的字符串带类型带编码)

QByteArray

在Qt中 QByteArray 可以看做是C语言中 char*的升级版本。我们在使用这种类型的时候可通过这个类的构造函数申请一块动态内存自己开辟一个内存空间，用于存储我们需要处理的字符串数据，通过这个类进行管理。

下面给大家介绍一下这个类中常用的一些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);

#include<QByteArray>
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    //有参构造
    //字节数组:没有编码放的是什么输出就是什么 而且一个字节一个字节的输出 一个中文三个字节
    QByteArray name("乘风破浪");
    //qDebug所有类型都支持输出 重载了左移运算符
    qDebug()<<name;

    //无参构造
    QByteArray str;
    //str<<"hello";  不支持流操作
    //重载了赋值运算符 可以直接赋值一个字符串
    str = "hello";    
    qDebug()<<str;
   
    char* str1 = "maye is man";
    QByteArray s(str1);
    qDebug()<<s;
    //指定长度 只要4个字符
    QByteArray s(str1,4);
    qDebug().noquote()<<s; //不带双引号的输出 访问成员
    return a.exec();
}
"\xE4\xB9\x98\xE9\xA3\x8E\xE7\xA0\xB4\xE6\xB5\xAA"
"hello"                    //字母只占一个字节 所有的英文都是ascii编码
"maye is man"
maye

数据操作 - - - > 增删改查

// 其他重载的同名函数可参考Qt帮助文档, 此处略
QByteArray &QByteArray::append(const QByteArray &ba);       //追加在最后面
void QByteArray::push_back(const QByteArray &other);        //为了和c++一样有的函数

// 其他重载的同名函数可参考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);

#define qout qDebug()   //取别名qout
#include<QByteArray>
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    char* str1 = "maye is man";
    QByteArray s(str1);
    //后面追加
    s.append("ok");
    s.push_back("ok");
    //前面追加
    s.prepend("you");
    s.push_front("1");
    qout<<s;
    s.remove(1,3);       //从第1个位置开始删,删除3个字符
    s.chop(4);           //删除尾部的4个字符
    s.truncate(5);       //从第5个位置开始 后面全部截断
    s.clear();           //全部清空
    qout<<s;
    retutn a.exec();
}
/*输出*/
"1youmaye is manokok"
"1maye is manokok"
"1maye is man"
"1maye"
""

子字符串查找和判断

//都属于重载 有就返回true,没有就返回false
// 判断字节数组中是否包含子字符串 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;

#include<QByteArray>
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    QByteArray str("hello welcome learn Qt");
    //查找字符串中是否有Qt子串
    if(str.contains("Qt"))
    {
        qout<<"有Qt";
    }
    else
    {
        qout<<"没有Qt";
    }
    //是否以指定的字符串开始
    if(str.startWith("he"))
    {
        qout<<"有 he";
    }
    //是否以指定的字符串结尾
    if(str.endWith("C"))
    {
        qout<<"有C";
    }
    return a.exec();
}

/*输出*/
有Qt
有 he

遍历 - - - > 一个个字符的查看

// 使用迭代器
iterator QByteArray::begin();
iterator QByteArray::end();

// 使用数组的方式进行遍历
// i的取值范围 0 <= i < size()
char QByteArray::at(int i) const;
char QByteArray::operator[](int i) const;

//字符的遍历
//1.迭代器 ch:变量 str:容器
for(auto ch: str)    //C++11新标准 用前面的变量把后面的容器中的值一个个取出来给ch 就可以一个个输出 会自动判断是否结束
{
    qout<<ch;        //输出字符串才带"",输出字符不带""
}
for(auto it = str.begin();it!=str.end();it++)
{
    qout<<*it;       //auto == QByteArray::iterator 自动类型推断
}
//2.使用下标法 需要知道str的长度
for(int i=0;i<str.size();i++)
{
    qout<<str[i];
}
h
e
l
1
o

w
e
l
c
o
m
e

l
e
a
r
n

Q
t

查看字节数

// 返回字节数组对象中字符的个数
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;

//获取字符串长度
qout<<str.size()<<str.length()<<str.count();    //22 22 22
//查看str中Q出现的次数
qout<<str.count('Q');                           //1

类型转换 c语言中把整型格式化为字符串 sprintf()

// 将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 进制:默认是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);   //格式:1.科学计数法 2.一般的形式 精度：默认小数点后面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 -> char*
QByteArray str("str");
char* pstr = str.data(); //获取char*类型

//int... -> QByteArray
str.setNum(520);         //10进制的520
qout<<str;
str.setNum(520,16);      //16进制的520自动转换为10进制
qout<<str;

str.setNum(3.1415);
str.setNum(3.1415,'g',2);//默认格式是'g',精度设置为2[包含整数部分]
qout<<str;

str.setNum(314.15,'E');
qout<<str;
auto num = QByteArray::number(620); //返回QByteArray的对象
qout<<num;
/*输出*/
"520" --->字符串
"208"
"3.1415"
"3.1"
"3.141500E+02"   3.1415*10^2
"620"

QString

QString也是封装的字符串, 但是内部的编码为utf8, UTF-8属于Unicode字符集, 它固定使用多个字节（window为2字节, linux为3字节）来表示一个字符，这样可以将世界上几乎所有语言的常用字符收录其中。

下面给大家介绍一下这个类中常用的一些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()函数用来格式化字符串

 QString res =  QString::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"

不同字符串类型相互转换

// std::string -> QString
[static] QString QString::fromStdString(const std::string &str);
// QString -> std::string
std::string QString::toStdString() const;

#QString -> QByteArray
// 转换为本地编码, 跟随操作系统
QByteArray QString::toLocal8Bit() const;
// 转换为 Latin-1 编码的字符串 不支持中文
QByteArray QString::toLatin1() const;
// 转换为 utf8 编码格式的字符串 (常用)
QByteArray QString::toUtf8() const;

#QByteArray -> QString
//使用QString的构造函数即可

#include<QString>
int main(int argc, char *argv[])
{
    QCoreApplication a(argc,argv);
    QString name = Qstring::asprintf("I'm %s,%d years old","maye",18); //静态成员函数通过类名去访问 把字符串格式化后返回用name接收
    qDebug()<<name;

    //Qt独有的 使用占位符,和arg函数
    //占位符 %1 %2 %3 1 2 3表示它所在的位置通过arg函数给它进行替换:第一个会替换到%1的位置,第2个会替换到%2的位置 
    //arg函数返回的就是一个QString 所以可以把它连接起来 
    //注意要接收QString的返回值
    auto say1 = Qstring(I'm %1,%2 years old").arg("haha").arc(25);
    auto say2 = Qstring(I'm %2,%1 years old").arg("haha").arc(25);
    qDebug()<<say1;
    qDebug()<<say2;

    QByteArray arr("hello");
    arr = "你好";        //6 一个中文3个字节
    QString str("hello");
    str = "你好";        //2 这个2不是字节大小 是字符个数:英文字母是一个字符中文一个字也是一个字符 
    //QString存储的是Qchar而不是char:一个Qchar是两个字节
    QDebug()<<arr.size()<<str.size(); //和length() count()一样
} 

/*输出*/

"I'm maye,18 years old"
"I'm haha,25 years old"
"I'm 25,haha years old" //haha是第一个位置 在前面找%1的位置 把haha放在%1的位置去 支持各种类型
5 5                     
6 2                     //字节数组输出字节数 字符串输出字符数

QVariant - - - 万能类型

QVariant(变体数据类型)这个类很神奇，或者说方便。很多时候，需要几种不同的数据类型需要传递，如果用结构体，又不大方便，容器保存的也只是一种数据类型，而QVariant则可以统统搞定。

QVariant 这个类型充当着最常见的数据类型的联合。QVariant 可以保存很多Qt的数据类型，包括QBrush、QColor、QCursor、QDateTime、QFont、QKeySequence、 QPalette、QPen、QPixmap、QPoint、QRect、QRegion、QSize和QString，并且还有C++基本类型，如int、float等。

联合：赋值一个int，通过 char 读，能够读到一个字符。

重载了很多不同的类型。

标准类型

将标准类型转换为QVariant类型

// 这类转换需要使用QVariant类的构造函数, 由于比较多, 大家可自行查阅Qt帮助文档, 在这里简单写几个
QVariant(int val);
QVariant(bool val);
QVariant(double val);
QVariant(const char *val);
QVariant(const QByteArray &val);
QVariant(const QString &val);
......
    
// 使用设置函数也可以将支持的类型的数据设置到QVariant对象中
// 这里的 T 类型, 就是QVariant支持的类型 模板函数|任何类型都可以传入
void setValue(const T &value);
// 该函数行为和 setValue() 函数完全相同
[static] QVariant fromValue(const T &value);

//测试代码
#include<QVariant>
int main(int argc, char *argv[])
{
    QCoreApplication a(argc,argv);
    //存入数据 1.通过构造函数存储数据 2.通过setValue()存储数据
    QVariant var(125);
    QVariant var1("hello");
    var1.setValue(9.62);
    //取出数据
    qDebug()<<var<<var1;
    qDebug()<<var.toInt()<<var1.toString();           //将QVariant对象转换为实际的数据类型
    qDebug()<<var.value<int>()<<var1.value<QString>();//直接转会报错 不知道要转换为什么类型的值 需要显式指定模板
    qDebug()<<var.type()<<var.typeName();             //判断 QVariant中封装的实际数据类型
    return a.exec();
}
/*输出*/

QVariant(QString,"hello")               //字符串默认QString类型 
QVariant(int,125) QVariant(double,9.62) //标明是什么类型的 值是多少
125 "9.62"
125 "9.62"
QVariant::int int                       //类型 类型名

Exmple

QVariant v(5);

QVariant v;
v.setValue(5);

QVariant v = QVariant::fromValue(5);

int i = v.toInt();          // i is now 5
QString s = v.toString();   // s is now "5"

判断 QVariant中封装的实际数据类型

Type 是枚举类型

//获取类型，返回的是一个枚举类型;如QVariant::Int ...
Type type() const;
//获取类型名
const char *typeName() const;
//根据类型id(枚举)获取类型名(字符串)
[static] const char *typeToName(int typeId);
//根据类型名(字符串)获取类型id(枚举)
[static] Type nameToType(const char *name);

将QVariant对象转换为实际的数据类型

//在转换之前可以先判断能够转换成对应的类型
bool canConvert(int targetTypeId) const
bool canConvert() const

bool 		toBool() const;
QByteArray 	toByteArray() const;
double 		toDouble(bool *ok = Q_NULLPTR) const;
float 		toFloat(bool *ok = Q_NULLPTR) const;
int 		toInt(bool *ok = Q_NULLPTR) const;
QString 	toString() const;
......

T value() const
//v.value<int>();

自定义类型

除了标准类型, 我们自定义的类型也可以使用QVariant类进行封装, 被QVariant存储的数据类型需要有一个默认的构造函数和一个拷贝构造函数。为了实现这个功能，首先必须使用Q_DECLARE_METATYPE()宏。通常会将这个宏放在类的声明所在头文件的下面，原型为：

Q_DECLARE_METATYPE(Type)---> 注册自定义类型

只有注册自定义类型才能存储数据，否则不能存储数据

使用的具体步骤如下:

第一步: 定义类型，并注册

//自定义类型
class Animal
{
public:
    Animal(){}  //必须要有默认构造函数
                //拷贝构造函数也必须有，不过没有深、浅拷贝时，用默认的即可
    Animal(QString name):_name(name){}
    void show()
    {
        qDebug()<<"Animal show name is :"<< _name <<endl;
    }
private:
    QString _name;
};
//自定义类型注册
Q_DECLARE_METATYPE(Animal);

第二步: 使用forvalue()存储对象

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
bool canConvert() const;
// 将当前QVariant对象转换为实际的 T 类型
T value() const;

//测试代码
class Person
{
public:
    Person()                   //必须要有一个无参的构造函数
    Person(int age);
    int mage;
};
Person::Person():m_age(0){}
Person::Person(int age):m_age(age){}
Q_DECLARE_METATYPE(Person);     //注册自定义类型,告诉Qt有这个类型
int main(int argc, char *argv[])
{
    QCoreApplication a(argc,argv);
    Person per;
    //自定义的类型,不能通过构造函数构造 报错:QVariant p(per);
    //使用特定的函数
    p.setValue(per);            //模板函数void setValue(const T &avalue)
    qDebug()<<p<<p.typeName();
    //取出数据
    auto pp=p.value<Person>();
    qDebug()<<pp;
    return a.exec();
}
/*输出*/
QVariant(Person, ) Person      
0

qiuqiuyaq

关注

6
点赞
踩
20

收藏

觉得还不错? 一键收藏
打赏
1
评论
Qt --- 基本类

基础类型因为Qt是一个C++框架, 因此C++中所有的语法和数据类型在Qt中都是被支持的, 但是Qt中也定义了一些属于自己的数据类型(大部分是c++数据类型的别名), 下面给大家介绍一下这些基础的数类型QT基本数据类型定义在#include <QtGlobal> 中，QT基本数据类型有：类型名称注释备注 qint8 signed char 有符号8位数据 qint16 signed short 16位数据类型 qint32 s
复制链接

扫一扫