属性基础
c.h文件:
#ifndef C_H
#define C_H
#include<QObject>
class A:public QObject{
Q_OBJECT
public: /*通常,若属性名为 a,则相应的读取函数通常命名为 geta,设置函数命名为 seta,本例并未使用这种命名
规则*/
//声明一个类型为 int,名称为 a 的属性,并使用函数 f 读取属性值,使用函数 g 设置属性值。
Q_PROPERTY(int a READ f WRITE g)
//声明一个类型为 int,名称为 b 的属性,并把该属性与成员变量 m_b 相关联,该属性未设置存取函数。
Q_PROPERTY(int b MEMBER m_b)
//声明一个只读属性 c,本例没有设置该属性值的函数,因此该属性是只读的。
Q_PROPERTY(int c READ getc)
/*在存取函数中可把属性与成员变量相关联,方法如下所示。对存取函数的返回类型和参数类型及数量在本
例影响不大,在后文会讲解其影响。*/
int f(){return m_a;} //属性 a 的读取函数。
void g(int i){m_a=i;} //属性 a 的设置函数。
int getc(){m_c=3; return m_c;} /*成员变量也可以不与属性相关联,本函数也可直接返回数值 3。
从此处可看到,属性可以不与数据成员相关联。*/
int m_a,m_b; //属性若命名为 a,则与其相对应的成员变量习惯上应命名为 m_a。
private://成员变量通常都应声明为私有的,这样可提高程序的封装性。
int m_c;
};
#endif // C_H
main.cpp文件:
void fun_3()
{
A ma;
//像普通成员变量一样存取属性值
ma.m_a=1;
cout<<ma.m_a<<endl; //输出 1
//因为属性 b 没有存取函数,本例暂时只使用普通成员变量的方式存取该属性值。
ma.m_b=2;
cout<<ma.m_b<<endl; //输出 2
ma.g(4); //使用属性 a 的设置函数修改属性值。
cout<<ma.f()<<endl; // 输出 4,使用属性 a 的读取函数读取属性值。
cout<<ma.getc()<<endl; /*输出 3,属性 c 是只读的,只能通过他的读取函数访问其值,因为没有设置
函数,因此无法改变属性 c 的值。*/
}
QVariant:基础
class C{}; // 自定义类型
void fun_4(){
QVariant v('a'); /*QVariant 没有专门的 char 构造函数,此处的字符 a 会被转换为 int 型,因此 v
中存储的是数值 97,而不是字符 a 。*/
cout<<v.value<int>()<<endl; //输出 97
cout<<v.value<char>()<<endl; //输出 a,将 97 转换为 char 型,并输出转换后的值。
cout<<v.toChar().toLatin1()<<endl; /*输出 a,原因同上,注意 toChar 返回的类型是 QChar 而不
是 char。*/
cout<<v.toString().toStdString()<<endl; /*输出 97,把存储在 v 中的值转换为 QString,然后以字
符串形式输出。*/
cout<<v.typeName()<<endl; //输出 int,可见存储在 v 中的值的类型为 int
cout<<v.typeToName(v.type())<<endl; /*输出 int,其中 type 返回存储值的枚举形式表示的类型,而
typeToName 则以字符串形式显示该枚举值所表示的类型。*/
char c='b';
v.setValue(c);
cout<<v.toString().toStdString()<<endl; //输出 b
cout<<v.typeName()<<endl; /*输出 char,若是使用 QVariant 构造函数和直接赋值 char 型字符,此
处会输出 int,这是 setValue 与他们的区别。*/
C mc; //自定义类型 C 的对象 mc
//QVariant v1(mc); //错误,没有相应的构造函数。
QVariant v2;
//v2=mc; //错误,没有与类型 C 匹配的赋值运算符函数。
//v2.setValue(mc); //错误,自定义类型 C 未使用宏 Q_DECLARE_METATYPE 声明。
}
QVariant:声明与注册用户自定义类型
class A{public: int i;};
class B{public:int i;};
class D{public:D(int){}};//该类无 public 默认构造函数
class E{ };
class F:public QObject{};
//声明类型
Q_DECLARE_METATYPE(A)
Q_DECLARE_METATYPE(B)
//Q_DECLARE_METATYPE(D) //错误,类 D 没有公有的默认构造函数
//Q_DECLARE_METATYPE(F) //错误,因为父类 QObject 的复制构造函数、赋值运算符等是私有的。
void fun_5()
{
//注册类型
qRegisterMetaType<B>();
// qRegisterMetaType<E>(); //错误,类型 E 未使用宏 Q_DECLARE_METATYPE(T)声明
// qRegisterMetaType<F>(); //错误,因为父类 QObject 的复制构造函数、赋值运算符等是私有的
A ma; ma.i=1;
B mb; mb.i=2;
//QVariant v1(ma); //错误,没有相应的构造函数。
QVariant v;
v.setValue(ma); //将对象 ma 存储在 v 之中
cout<<v.value<A>().i<<endl; //输出 1。
cout<<v.typeName()<<endl; //输出 A
cout<<v.toString().toStdString()<<endl; //输出一个空字符,因为 ma 是一个对象,不是一个值。
//自定义类型需要使用 userType 才能返回正确的类型 ID。
cout<<v.typeToName(v.userType())<<endl; //输出 A
cout<<v.typeToName(v.type())<<endl; //不一定输出 A。
A ma1;
ma1=v.value<A>(); //把存储在 v 之中的对象 ma 赋值给 ma1
cout<<ma1.i<<endl; //输出 1,可见赋值成功。
B mb1;
//mb1=v.value<A>(); //错误,类型不相同。
mb1=v.value<B>(); //失败,由类型 A 转换到类型 B 失败,此时 value 会返回一个默认构造的值。
cout<<mb1.i<<endl; //输出 0。
}
使用 QObject 类中的成员函数存取属性值与动态属性
d.h文件:
#ifndef D_H
#define D_H
#include<QObject>
class B{public:int i;};
class C{public:int i;};
class D{public:int i;};
Q_DECLARE_METATYPE(B)
Q_DECLARE_METATYPE(C)
class Z:public QObject{
Q_OBJECT
public: Z(){}
Q_PROPERTY(B b READ fb WRITE gb)
Q_PROPERTY(C c READ fc WRITE gc)
Q_PROPERTY(D d READ fd WRITE gd)
B fb(){return m_mb;} void gb(B x){m_mb=x;}
C fc(){return m_mc;} void gc(C x){m_mc=x;}
D fd(){return m_md;} void gd(D x){m_md=x;}
B m_mb; C m_mc; D m_md;
};
#endif // D_H
main.cpp文件:
void fun_6(){
qRegisterMetaType<B>();
qRegisterMetaType<C>();
B mb; C mc; D md; Z mz;
mb.i=2; mc.i=3; md.i=4;
mz.gb(mb); mz.gc(mc); mz.gd(md);
//使用 porperty 和 setProperty 存取属性值。
//mz.property("d"); //错误,不能使用 property 函数访问属性 d,因为属性 d 的类型 D 未注册。
mz.property("MMM"); /*这是正确的,因为属性 MMM 不存在,所以,返回的是一个空的 QVariant 对象,
可见,属性不存在与属性的类型未注册是不同的。*/
cout<<mz.fd().i<<endl; /*输出 4。虽然不能使用 property 函数访问属性 d,但仍可使用存取函数
访问该属性的值。*/
QVariant v; B mb1;
mb1.i=6; v.setValue(mb1);
//mz.setProperty("b",mb1); //错误,第二个参数的类型不匹配。
mz.setProperty("b",v); //正确设置属性 b 的值的方法,把属性 b 的值设置为 v 中存储的值 mb1。
mz.setProperty("c",v); /*正确,但是属性 c 的类型与 v 中存储的值的类型不兼容,因此属性 c 不
会被更改*/
mz.setProperty("c",7); //原因同上。
cout<<mz.property("b").typeName()<<endl; //输出 B,输出属性 b 的类型
cout<<mz.property("c").typeName()<<endl; //输出 C,输出属性 c 的类型
cout<<mz.property("b").value<B>().i<<endl; //输出 6。输出的是 mb1.i 的值。
cout<<mz.property("c").value<C>().i<<endl; //输出 3,属性 c 的值并未被更改。
//动态属性
mc.i=7; v.setValue(mc);
// mz.setProperty("w",mc); //错误,第二个参数的类型不匹配。
mz.setProperty("x",v); //动态属性,新增加属性 x,并设置其值为 v 中存储的值(即 mc)
cout<<mz.property("x").typeName()<<endl; //输出 C,即动态属性 x 的类型。
cout<<mz.property("x").value<C>().i<<endl; //输出 7。
Z mz1;
//cout<<mz1.property("x").typeName()<<endl; //错误,动态属性 x 是基于对象 mz 的。
cout<<mz1.property("b").typeName()<<endl; //输出 B,属性 b 不是动态属性。
}
使用反射机制获取属性的信息
class Z:public QObject{
Q_OBJECT
public:
Q_PROPERTY(int b READ gb WRITE sb)
int gb(){return m_mb;} void sb(int x){m_mb=x;}
int m_mb;
};
void fun_7(){
Z mz;
const QMetaObject *p=mz.metaObject();
QMetaProperty pe=p->property(p->indexOfProperty("b")); //获取属性 b 的元数据。
cout<<pe.name()<<endl; //输出属性的名称 b
cout<<pe.typeName()<<endl; //输出属性 b 的类型 int
pe.write(&mz,47); //把值 47 写入属性 b
cout<<pe.read(&mz).value<int>()<<endl; //输出属性 b 的值 47。
}