Speichern einer Klasse in qsettings

Question

Ich habe eine Klasse, die ein QObject ist und es hat ein Mitglied, das eine Unit * ist.

Die Einsparung beschwert, dass es nicht eine Einheit speichern *

[26.04 12:53:21 W] QVariant::save: unable to save type 'Unit*' (type id: 1362). 

Ich habe versucht, es zu registrieren qRegisterMetaTypeStreamOperators<Unit*>("Unit*"); aber bekomme ich folgende Fehler

/usr/include/qt/QtCore/qvariant.h:465: error: 'QVariant::QVariant(void*)' is private 
    inline QVariant(void *) Q_DECL_EQ_DELETE; 
      ^

Hier ist mein Laden und Speichern Mechanismus

void Profile::save(QSettings& settings) const { 
    for(int i=0; i<metaObject()->propertyCount(); ++i) { 
     const auto& p = metaObject()->property(i); 
     if(p.isStored(this)) { 
      settings.setValue(p.name(), property(p.name())); 
     } 
    } 
} 

void Profile::load(QSettings& settings) { 
    for(int i=0; i<metaObject()->propertyCount(); ++i) { 
     const auto& p = metaObject()->property(i); 
     if(p.isStored(this)) { 
      setProperty(p.name(), settings.value(p.name())); 
     } 
    } 
} 

Hier ist meine Einheitsklasse

Unit::Unit(int unit, QObject *parent) 
    : EraObject(parent), 
     m_value(0.0), 
     m_unit(unit) 
{ 
    connect(eApp->systemController()->unitManager(),&UnitManager::onUnitChanged,this,&Unit::changeUnit); 
} 

Unit::Unit(const Unit &other) 
{ 
    m_value = other.m_value; 
    m_unit = other.m_unit; 
    qRegisterMetaTypeStreamOperators<Unit*>("Unit*"); 
} 

Unit &Unit::operator=(const qreal value) 
{ 
    if (m_value == value) 
     return *this; 

    m_value = value; 
    emit userValueChanged(); 

    return *this; 
} 


void Unit::loadFrom(Settings &set, bool ownGroup) 
{ 
    Q_UNUSED(ownGroup) 
    if(set.contains(objectName())) { 
     m_value = set.value(objectName(),0.0).toDouble(); 
     emit userValueChanged(); 
    } 
} 

void Unit::saveTo(Settings &set, bool ownGroup, bool force) 
{ 
    Q_UNUSED(ownGroup) 
    Q_UNUSED(force) 
    set.setValue(objectName(),m_value); 
} 

Unit::operator qreal() const 
{ 
    return m_value; 
} 

qreal Unit::userValue() const 
{ 
    return isDefault() ? m_value : UnitManager::convertTo(m_value,m_unit); 
} 

QString Unit::symbol() const 
{ 
    return UnitManager::symbolName(m_unit); 
} 

void Unit::setUserValue(const qreal userValue) 
{ 
    qDebug() << "setUserValue" << this->userValue() << userValue << QString::number(m_unit,2); 
    if (this->userValue() == userValue) 
     return; 

    if(isDefault()) 
     m_value = userValue; 
    else 
     m_value = UnitManager::convertFrom(userValue,m_unit); 

    qDebug() << "Value" << m_value; 

    emit userValueChanged(); 
    setDirty(RamDirty); 
} 

void Unit::setup(quint32 unit, const QString name, QObject *parent) 
{ 
    if(!m_unit) 
     m_unit = (unit << 16); 
    setObjectName(name); 
    setParent(parent); 
    connectDirtyWithParent(parent); 
} 

void Unit::changeUnit(const quint32 &unit) 
{ 
    if(m_unit == unit || category() != (unit >> 16)) 
     return; 
    m_unit = unit; 
    emit userValueChanged(); 
    emit symbolChanged(); 
} 

UPDATE:

jetzt habe ich versucht,

QDataStream& operator<<(QDataStream& out, const Unit& v) { 
    out << v.userValue(); 
    return out; 
} 

QDataStream& operator>>(QDataStream& in, Unit& v) { 
    in >> v.userValue(); 
    return in; 
} 

und ich

/home/ahmed/server/elec/software_t/backup17/checko5/eracommon5/src/cpp/system/unit/unit.cpp:21: error: ambiguous overload for 'operator<<' (operand types are 'QDataStream' and 'qreal {aka double}') 
    out << v.userValue(); 
     ^

UPDATE2 erhalten zu schreiben:

QDataStream &Unit::operator <<(QDataStream &out, Unit &val) 
{ 
    out << val.userValue(); 
    return out; 
} 

QDataStream &Unit::operator >>(QDataStream &out, Unit &val) 
{ 
    in >> val.userValue(); 
    return in; 
} 

Update 3:

Unit::Unit(int unit, QObject *parent) 
    : EraObject(parent), 
     m_value(0.0), 
     m_unit(unit) 
{ 
    connect(eApp->systemController()->unitManager(),&UnitManager::onUnitChanged,this,&Unit::changeUnit); 
    qRegisterMetaTypeStreamOperators<Unit>("Unit"); 

} 

Unit::Unit(const Unit &other) 
{ 
    m_value = other.m_value; 
    m_unit = other.m_unit; 
} 


QDataStream &operator<<(QDataStream &out, const Unit &unit) 
{ 
    out << unit.value(); 
    return out; 
} 
QDataStream &operator>>(QDataStream &in, Unit &unit) 
{ 
    in >> unit.value(); 
    return in; 
} 

Answer 1

Hier ist die Dokumentation für qRegisterMetaTypeStreamOperators(). Starten Sie dort Ihre Streaming-Betreiber zu beheben, das heißt, es sollte wie folgt aussehen:

QDataStream &operator<<(QDataStream &out, const Unit &unit); 
QDataStream &operator>>(QDataStream &out, Unit &unit); 

Andernfalls wird der Teil des Codes korrekt ist.

Die zweite Lösung ist, dass Sie keinen Zeiger mit registrieren können. Sie müssen die Art sich registrieren: (? Sie qRegisterMetaType() auch genannt haben, rechts)

qRegisterMetaTypeStreamOperators<Unit>("Unit"); 

Schließlich qRegisterMetaType() und qRegisterMetaTypeStreamOperators() sollte nur einmal aufgerufen werden. Wenn Sie die Dokumentation für QMetaType::load() beachten, sollten diese Funktionen nur einmal aufgerufen werden (zB in int main() oder einem anderen Initialisierungscode.