C++ 重写QObject:：setProperty

我想重写

QObject:：setProperty（const char*，QVariant）

，因为当我用

QVariant

调用这个方法时，它包含一个

QVariantList

方法失败，因为它没有将

QVariantList

转换为

QList

有什么建议吗

编辑

我有一个抽象类

节点

，它包含

}

上下文

类如下所示：

---

这样，在一个

setDataPersisted

之后，另一个

setDataPersisted

（to“append”）和一个

getDataPersisted

数据列表被破坏。

使用

Q\u DECLARE\u METATYPE

宏在Qt元类型系统中注册

QVariantList

。这将允许将

QVariantList

存储为

QVariant

    Q_DECLARE_METATYPE(QVariantList);
...
    QVariantList var;
    QVariant v = QVariant::fromValue<QVariantList>( var );
    QVariantList lst = v.value<QVariantList>();

要将

QVariantList

转换为

QList

：

qvariantlistlst2；
...
QList-lst1；
用于（常数QVariant&st:lst2）
lst2.追加（st.value（））；

编辑1:

auto it = _stack.find(name);
if (_stack.end() == it) {
    it = _stack.insert( name, QVariant::fromValue<QVariantList>(QVariantList()) );
}
QVariantList toChange = it->value().value<QVariantList>();
toChange.append(value);
_stack.insert(name, QVariant::fromValue<QVariantList>(toChange) );

autoit=\u stack.find（名称）；
if（_stack.end（）==it）{
它=_stack.insert（名称，QVariant:：fromValue（QVariantList（））；
}
QVariantList toChange=it->value（）.value（）；
toChange.append（值）；
_insert（名称，QVariant:：fromValue（toChange））；

重载setter函数？是什么阻止您自己进行转换？如果重载

QObject:：setProperty

，则您将制作自定义Qt库，并且此库将与其他Qt库不兼容。尝试以@vahancho sais的身份进行转换，避免修改Qt库。顺便说一句，您不能重写

QObject:：setProperty（）

函数，因为它不是虚拟函数。确定。我在

节点

类中使用

setProperty

方法初始化子类的属性。

节点

类将位于sdk中，但子类不在sdk中。所以我不知道我必须初始化的属性实类型。是的，但问题是我不知道

SomeType

。也许有一个解决方案使用了

QMetaType

？@artoon如果你有一个QVariant列表，每个都是不同的类型，你可以使用QVariant:：canConvert和QVariant:：convert函数，但在我的例子中，它们都是相同的类型。如何使用

QVariant:：convert

？@artoon使用QVariant:：value模板函数，但我不能在我的

Node

类中使用

QVariant:：value

，因为有了它，

Node

类将不会独立于属性实类型。

class Context : public QObject
{
Q_OBJECT
public:
Context(Context* parent = NULL) : : _parent(parent){}
void setDataPersisted(QString name, QVariant value)
{
    if(_parent != NULL && _parent->exist(name))
        _parent->setDataPersisted(name, value);
    else
    {
        if(_stack.contains(name))
            _stack.insert(name, value);
        else
            _stack.insert(name, value);
     }
}
QVariant getDataPersisted(QString name)
{
    QVariant v;
    QMap<QString, QVariant>::iterator it = _stack.find(name);
    if(it != _stack.end())
        v.setValue(it.value());
    else
        if(_parent != NULL)
            v.setValue(_parent->getDataPersisted(name));
    return v;
}
private:
bool exist(QString name)
{
    bool contains = _stack.contains(name);
    return contains || ((_parent != NULL) && (_parent->exist(name)));
}
private:
    Context * _parent;
    QMap<QString, QVariant> _stack;
};

void setDataPersisted(QString name, QVariant value)
{
    if(_parent != NULL && _parent->exist(name))
        _parent->setDataPersisted(name, value);
    else
    {
        if(_stack.contains(name) && _stack.find(name)->value().canConvert(QVariant::List))
        {
            QVariantList toChange = qvariant_cast<QVariantList>(_stack.find(name)->value());
            toChange.append(value);
            _stack.insert(name, toChange );
        }
        else
            _stack.insert(name, value);
     }
}

    Q_DECLARE_METATYPE(QVariantList);
...
    QVariantList var;
    QVariant v = QVariant::fromValue<QVariantList>( var );
    QVariantList lst = v.value<QVariantList>();

QList<SomeType> lst1;
...
QVariantList    lst2;

for (const SomeType& st : lst1)
    lst2.append( QVariant::fromValue<SomeType>( st ) ); 

QVariantList    lst2;
...
QList<SomeType> lst1;

for (const QVariant& st : lst2)
    lst2.append( st.value<SomeType>() ); 

auto it = _stack.find(name);
if (_stack.end() == it) {
    it = _stack.insert( name, QVariant::fromValue<QVariantList>(QVariantList()) );
}
QVariantList toChange = it->value().value<QVariantList>();
toChange.append(value);
_stack.insert(name, QVariant::fromValue<QVariantList>(toChange) );