QVariant Class

Dokumentation zu Mitgliedsfunktionen

[noexcept] QVariant::QVariant()

Erzeugt eine ungültige Variante.

[noexcept] QVariant::QVariant(QChar c)

Erstellt eine neue Variante mit einem Zeichenwert: c.

QVariant::QVariant(const QPersistentModelIndex &val)

Erstellt eine neue Variante mit dem Wert „ QPersistentModelIndex “, val.

[noexcept] QVariant::QVariant(const QRegularExpression &re)

Erstellt eine neue Variante mit dem regulären Ausdruck „ re “.

[noexcept] QVariant::QVariant(const QString &val)

Erstellt eine neue Variante mit dem Zeichenfolgenwert „ val “.

[noexcept] QVariant::QVariant(const QStringList &val)

Erstellt eine neue Variante mit einem Wert in Form einer Zeichenfolgenliste: val.

[noexcept] QVariant::QVariant(const QUrl &val)

Erstellt eine neue Variante mit dem URL-Wert val.

QVariant::QVariant(const char *val)

Erstellt eine neue Variante mit dem String-Wert „ val “. Die Variante erstellt eine tiefe Kopie von „ val “ in „ QString “, wobei von einer UTF-8-Kodierung der Eingabe „ val “ ausgegangen wird.

Beachten Sie, dass „ val “ zur Speicherung in der Variante in „ QString “ konvertiert wird und „ QVariant::userType()“ für die Variante „ QMetaType::QString “ zurückgibt.

Sie können diesen Operator deaktivieren, indem Sie beim Kompilieren Ihrer Anwendungen QT_NO_CAST_FROM_ASCII definieren.

[noexcept] QVariant::QVariant(double val)

Erstellt eine neue Variante mit einem Gleitkommawert: val.

[noexcept] QVariant::QVariant(float val)

Erstellt eine neue Variante mit einem Gleitkommawert: val.

[noexcept] QVariant::QVariant(int val)

Erstellt eine neue Variante mit einem ganzzahligen Wert: val.

[noexcept] QVariant::QVariant(qlonglong val)

Erzeugt eine neue Variante mit einem „long long“-Ganzzahlwert: val.

[noexcept] QVariant::QVariant(qulonglong val)

Erstellt eine neue Variante mit einem vorzeichenlosen „long long“-Ganzzahlwert: val.

[noexcept] QVariant::QVariant(uint val)

Erstellt eine neue Variante mit einem vorzeichenlosen ganzzahligen Wert: val.

[explicit] QVariant::QVariant(QMetaType type, const void *copy = nullptr)

Erstellt eine Variante vom Typ „ type “ und initialisiert diese mit einer Kopie von „ *copy “, sofern „ copy “ nicht „ nullptr “ ist (in diesem Fall muss „ copy “ auf ein Objekt vom Typ „ type “ verweisen).

Beachten Sie, dass Sie die Adresse des Objekts übergeben müssen, das gespeichert werden soll.

Normalerweise müssen Sie diesen Konstruktor nie verwenden; nutzen Sie stattdessen ` QVariant::fromValue()` zum Erstellen von Varianten aus den Zeigertypen, die durch ` QMetaType::VoidStar` und ` QMetaType::QObjectStar` repräsentiert werden.

Wenn type die Kopierkonstruktion nicht unterstützt und copy nicht gleich nullptr ist, ist die Variante ungültig. Ebenso ist die Variante ungültig, wenn copy gleich nullptr ist und type die Standardkonstruktion nicht unterstützt.

Siehe auch QVariant::fromMetaType, QVariant::fromValue() und QMetaType::Type.

[noexcept, since 6.12] QVariant::QVariant(QBitArray &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QByteArray &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QDateTime &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QEasingCurve &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QHash<QString, QVariant> &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QJsonArray &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QJsonDocument &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QJsonObject &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept(...), since 6.12] QVariant::QVariant(QJsonValue &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QList<QVariant> &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QLocale &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QMap<QString, QVariant> &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QPersistentModelIndex &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QRegularExpression &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QString &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QStringList &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[noexcept, since 6.12] QVariant::QVariant(QUrl &&val)

Diese Funktion wurde in Qt 6.12 eingeführt.

[explicit noexcept(...), since 6.6] template <typename T, typename... Args> requires if_constructible<T, Args...> QVariant::QVariant(std::in_place_type_t<T>, Args &&... args)

Erstellt eine neue Variante, die einen Wert vom Typ „ T “ enthält. Der enthaltene Wert wird mit den Argumenten „ std::forward<Args>(args)... “ initialisiert.

Dieser Konstruktor wird aus Gründen der Kompatibilität mit STL/std::any bereitgestellt.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn ` T ` aus ` args` konstruiert werden kann.

Diese Funktion wurde in Qt 6.6 eingeführt.

[explicit noexcept(...), since 6.6] template < typename T, typename U, typename... Args > requires if_constructible<T, std::initializer_list<U> &, Args...> QVariant::QVariant(std::in_place_type_t<T>, std::initializer_list<U> il, Args &&... args)

Diese Überladung dient zur Unterstützung von Typen mit Konstruktoren, die ein ` initializer_list` akzeptieren. Ansonsten verhält sie sich genauso wie die Überladung ` in_place_type_t ` ohne Initialisierungsliste.

Diese Funktion wurde in Qt 6.6 eingeführt.

[noexcept] QVariant::QVariant(QDate val)

Erstellt eine neue Variante mit einem Datumswert: val.

QVariant::QVariant(QLatin1StringView val)

Erstellt eine neue Variante mit dem Wert „ QString “ aus der Latin-1-Zeichenkette, die unter val angezeigt wird.

[noexcept(...)] QVariant::QVariant(QLine val)

Erstellt eine neue Variante mit dem Zeilenwert „ val “.

[noexcept(...)] QVariant::QVariant(QLineF val)

Erstellt eine neue Variante mit dem Zeilenwert „ val “.

[noexcept] QVariant::QVariant(QPoint val)

Erstellt eine neue Variante mit dem Punktwert „ val “.

[noexcept(...)] QVariant::QVariant(QPointF val)

Erstellt eine neue Variante mit dem Punktwert „ val “.

[noexcept(...)] QVariant::QVariant(QRect val)

Erstellt eine neue Variante mit dem Wert „ val “ für „rect“.

[noexcept(...)] QVariant::QVariant(QRectF val)

Erstellt eine neue Variante mit dem Wert „ val “ für „rect“.

[noexcept] QVariant::QVariant(QSize val)

Erstellt eine neue Variante mit dem Größenwert „ val “.

[noexcept(...)] QVariant::QVariant(QSizeF val)

Erstellt eine neue Variante mit dem Größenwert „ val “.

[noexcept] QVariant::QVariant(QTime val)

Erstellt eine neue Variante mit einem Zeitwert: val.

[noexcept(...)] QVariant::QVariant(QUuid val)

Erstellt eine neue Variante mit einem UUID-Wert: val.

[delete] template <typename T, std::enable_if_t<std::disjunction_v<std::is_pointer<T>, std::is_member_pointer<T>>, bool> = false> QVariant::QVariant(T)

Erzeugt standardmäßig eine Instanz von „ QVariant “. Diese Funktion wurde gelöscht.

[noexcept] QVariant::QVariant(bool val)

Erstellt eine neue Variante mit einem booleschen Wert: „ val “.

[noexcept] QVariant::QVariant(const QBitArray &val)

Erstellt eine neue Variante mit einem Bitarray-Wert: val.

[noexcept] QVariant::QVariant(const QByteArray &val)

Erstellt eine neue Variante mit einem Bytearray-Wert: val.

[noexcept] QVariant::QVariant(const QDateTime &val)

Erstellt eine neue Variante mit einem Datums-/Zeitwert: val.

QVariant::QVariant(const QEasingCurve &val)

Erstellt eine neue Variante mit dem Wert einer Beschleunigungskurve: val.

[noexcept] QVariant::QVariant(const QHash<QString, QVariant> &val)

Erstellt eine neue Variante mit einem Hash aus den Werten „ QVariant“ und „ val “.

[noexcept] QVariant::QVariant(const QJsonArray &val)

Erstellt eine neue Variante mit einem JSON-Array-Wert: val.

QVariant::QVariant(const QJsonDocument &val)

Erstellt eine neue Variante mit dem Wert eines JSON-Dokuments: val.

[noexcept] QVariant::QVariant(const QJsonObject &val)

Erstellt eine neue Variante mit dem Wert eines JSON-Objekts: val.

[noexcept(...)] QVariant::QVariant(const QJsonValue &val)

Erstellt eine neue Variante mit einem JSON-Wert: val.

[noexcept] QVariant::QVariant(const QList<QVariant> &val)

Erstellt eine neue Variante mit einem Listenwert: val.

[noexcept] QVariant::QVariant(const QLocale &l)

Erstellt eine neue Variante mit dem Locale-Wert „ l “.

[noexcept] QVariant::QVariant(const QMap<QString, QVariant> &val)

Erstellt eine neue Variante mit einer Zuordnung von QVariants zu val.

[noexcept(...)] QVariant::QVariant(const QModelIndex &val)

Erstellt eine neue Variante mit dem Wert „ QModelIndex “, val.

QVariant::QVariant(const QVariant &p)

Erstellt eine Kopie der Variante „ p “, die als Argument an diesen Konstruktor übergeben wurde.

[noexcept] QVariant::QVariant(QVariant &&other)

Erstellt eine QVariant-Instanz per Move-Konstruktion, sodass diese auf dasselbe Objekt verweist, auf das zuvor „ other “ verwiesen hat.

[noexcept] QVariant::~QVariant()

Löscht den „ QVariant “ und das darin enthaltene Objekt.

template <typename T> bool QVariant::canConvert() const

Gibt „ true “ zurück, wenn die Variante in den Vorlagentyp „ T “ konvertiert werden kann, andernfalls „false“.

Beispiel:

QVariant v = 42;

v.canConvert<int>();              // returns true
v.canConvert<QString>();          // returns true

MyCustomStruct s;
v.setValue(s);

v.canConvert<int>();              // returns false
v.canConvert<MyCustomStruct>();   // returns true

Ein ` QVariant `, der einen Zeiger auf einen von ` QObject ` abgeleiteten Typ enthält, gibt bei dieser Funktion ebenfalls `true` zurück, wenn eine ` qobject_cast ` zum Vorlagentyp ` T ` erfolgreich wäre. Beachten Sie, dass dies nur für Unterklassen von ` QObject ` funktioniert, die das Makro ` Q_OBJECT ` verwenden.

Siehe auch convert().

[since 6.0] bool QVariant::canConvert(QMetaType type) const

Gibt „ true “ zurück, wenn der Typ der Variante in den angeforderten Typ „ type “ umgewandelt werden kann. Eine solche Umwandlung erfolgt automatisch beim Aufruf der Methoden „ toInt()“, „ toBool()“ usw.

Beachten Sie, dass diese Funktion nur auf den Typ der Variante wirkt, nicht auf deren Inhalt. Sie gibt an, ob es einen Konvertierungspfad von dieser Variante zu „ type “ gibt, nicht jedoch, ob die Konvertierung bei einem Versuch erfolgreich sein wird.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch „ QMetaType::canConvert()“.

template <typename T> bool QVariant::canView() const

Gibt „ true “ zurück, wenn für diese Variante eine veränderbare Ansicht des Vorlagentyps „ T “ erstellt werden kann, andernfalls „ false “.

Siehe auch value().

void QVariant::clear()

Wandeln Sie diese Variante in den Typ „ QMetaType::UnknownType “ um und geben Sie alle verwendeten Ressourcen frei.

[static, since 6.0] QPartialOrdering QVariant::compare(const QVariant &lhs, const QVariant &rhs)

Vergleicht die Objekte unter lhs und rhs hinsichtlich ihrer Reihenfolge.

Gibt „ QPartialOrdering::Unordered “ zurück, wenn der Vergleich nicht unterstützt wird oder die Werte ungeordnet sind. Andernfalls gibt die Funktion „ QPartialOrdering::Less “, „ QPartialOrdering::Equivalent “ oder „ QPartialOrdering::Greater “ zurück, wenn „ lhs “ kleiner als, gleich oder größer als „ rhs “ ist.

Wenn die Varianten Daten mit unterschiedlichem Metatyp enthalten, gelten die Werte als ungeordnet, es sei denn, sie sind beide vom Typ „numerisch“ oder „Zeiger“; in diesem Fall kommen die regulären Vergleichsregeln für numerische Werte oder Zeiger zur Anwendung.

Wenn beide Varianten Daten desselben Metatypes enthalten, verwendet die Methode die Methode „ QMetaType::compare “, um die Reihenfolge der beiden Varianten zu bestimmen; dies kann auch bedeuten, dass keine Reihenfolge zwischen den beiden Werten festgelegt werden kann.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch ` QMetaType::compare()` und ` QMetaType::isOrdered()`.

Gibt einen Zeiger auf das enthaltene Objekt als generischen void*-Zeiger zurück, der nicht beschreibbar ist.

Siehe auch ` get_if()` und ` QMetaType`.

[since 6.0] bool QVariant::convert(QMetaType targetType)

Wandelt die Variante in den gewünschten Typ um: targetType. Kann die Umwandlung nicht durchgeführt werden, wird die Variante zwar dennoch in den gewünschten Typ umgewandelt, bleibt jedoch in einem geleerten Null-Zustand, ähnlich dem, der durch QVariant(Type) erzeugt wird.

Gibt „ true “ zurück, wenn der aktuelle Typ der Variante erfolgreich umgewandelt wurde; andernfalls wird „ false “ zurückgegeben.

Ein ` QVariant `, der einen Zeiger auf einen von ` QObject ` abgeleiteten Typ enthält, wird ebenfalls konvertiert und gibt für diese Funktion `true` zurück, wenn ein ` qobject_cast ` auf den durch ` targetType ` beschriebenen Typ erfolgreich wäre. Beachten Sie, dass dies nur für Unterklassen von ` QObject ` funktioniert, die das Makro ` Q_OBJECT ` verwenden.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch „ canConvert()“ und „ clear()“.

void *QVariant::data()

Gibt einen Zeiger auf das enthaltene Objekt als generischen void*-Zeiger zurück, auf den geschrieben werden kann.

Diese Funktion trennt die Verbindung zum „ QVariant “. Wird sie für einen „ null-QVariant “ aufgerufen, ist der „ QVariant “ nach dem Aufruf nicht mehr null.

Siehe auch „ get_if()“ und „ QMetaType “.

[since 6.6] template <typename T, typename... Args> requires if_constructible<T, Args...> T &QVariant::emplace(Args &&... args)

Ersetzt das derzeit in ` *this ` gespeicherte Objekt durch ein Objekt vom Typ ` T`, das aus ` args ` und `...` erstellt wurde. War ` *this ` nicht null, wird das zuvor gespeicherte Objekt zunächst zerstört. Falls möglich, wird bei dieser Methode der von ` QVariant` zugewiesene Speicher wiederverwendet. Gibt eine Referenz auf das neu erstellte Objekt zurück.

Diese Funktion wurde in Qt 6.6 eingeführt.

[since 6.6] template < typename T, typename U, typename... Args > requires if_constructible<T, std::initializer_list<U> &, Args...> T &QVariant::emplace(std::initializer_list<U> list, Args &&... args)

Diese Überladung dient zur Unterstützung von Typen mit Konstruktoren, die eine „ initializer_list “ annehmen. Ansonsten verhält sie sich genauso wie die Überladung ohne Initialisierungsliste.

Diese Funktion wurde in Qt 6.6 eingeführt.

[static, since 6.7] QVariant QVariant::fromMetaType(QMetaType type, const void *copy = nullptr)

Erstellt eine Variante vom Typ „ type “ und initialisiert sie mit einer Kopie von „ *copy “, sofern „ copy “ nicht „ nullptr “ ist (in diesem Fall muss „ copy “ auf ein Objekt vom Typ „ type “ verweisen).

Beachten Sie, dass Sie die Adresse des Objekts übergeben müssen, das gespeichert werden soll.

Normalerweise müssen Sie diesen Konstruktor nie verwenden; nutzen Sie stattdessen ` QVariant::fromValue()` zum Erstellen von Varianten aus den Zeigertypen, die durch ` QMetaType::VoidStar` und ` QMetaType::QObjectStar` repräsentiert werden.

Wenn type keine Kopierkonstruktion unterstützt und copy nicht nullptr ist, ist die Variante ungültig. Ebenso ist die Variante ungültig, wenn copy nullptr ist und type keine Standardkonstruktion unterstützt.

Gibt den wie oben beschrieben erstellten „ QVariant “ zurück.

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch „ QVariant::fromValue()“ und „ QMetaType::Type “.

[static] template <typename... Types> QVariant QVariant::fromStdVariant(const std::variant<Types...> &value)

Gibt ein ` QVariant ` mit dem Typ und dem Wert der aktiven Variante von ` value` zurück. Ist der aktive Typ `std::monostate`, wird ein Standard-` QVariant ` zurückgegeben.

Siehe auch ` fromValue()`.

[static, since 6.6] template <typename... Types> QVariant QVariant::fromStdVariant(std::variant<Types...> &&value)

Diese Funktion wurde in Qt 6.6 eingeführt.

[static] template <typename T> QVariant QVariant::fromValue(const T &value)

Gibt ein ` QVariant ` zurück, das eine Kopie von ` value` enthält. Ansonsten verhält sich die Funktion genau wie ` setValue()`.

Beispiel:

MyCustomStruct s;
return QVariant::fromValue(s);

Siehe auch setValue() und value().

[static, since 6.6] template <typename T> requires if_rvalue<T> QVariant QVariant::fromValue(T &&value)

Diese Funktion wurde in Qt 6.6 eingeführt.

bool QVariant::isNull() const

Gibt „ true “ zurück, wenn es sich um eine Null-Variante handelt, andernfalls „false“.

Eine Variante gilt als null, wenn sie keinen initialisierten Wert oder einen Nullzeiger enthält.

Siehe auch ` convert()`.

bool QVariant::isValid() const

Gibt „ true “ zurück, wenn der Speichertyp dieser Variante nicht „ QMetaType::UnknownType “ ist; andernfalls wird „ false “ zurückgegeben.

[since 6.0] QMetaType QVariant::metaType() const

Gibt den „ QMetaType “ des in der Variante gespeicherten Werts zurück.

Diese Funktion wurde in Qt 6.0 eingeführt.

void QVariant::setValue(QVariant &&value)

Verschiebt „ value “ auf „this QVariant “. Dies entspricht einfach der Zuweisung von „ value “ zu „this QVariant “.

Siehe auch value().

template <typename T, typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, QVariant>>> void QVariant::setValue(T &&value)

Speichert eine Kopie von ` value`. Wenn ` T ` ein Typ ist, den ` QVariant ` nicht unterstützt, wird ` QMetaType ` zum Speichern des Werts verwendet. Es tritt ein Kompilierungsfehler auf, wenn ` QMetaType ` den Typ nicht verarbeiten kann.

Beispiel:

QVariant v;

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

MyCustomStruct c;
v.setValue(c);

//...

MyCustomStruct c2 = v.value<MyCustomStruct>();

Siehe auch value(), fromValue() und canConvert().

void QVariant::setValue(const QVariant &value)

Kopiert value nach QVariant. Dies entspricht der einfachen Zuweisung von value zu QVariant.

[noexcept] void QVariant::swap(QVariant &other)

Tauscht diese Variante gegen „ other “ aus. Dieser Vorgang ist sehr schnell und schlägt niemals fehl.

QBitArray QVariant::toBitArray() const

Gibt die Variante als „ QBitArray “ zurück, wenn die Variante über „ userType()“ QMetaType::QBitArray verfügt; andernfalls wird ein leeres Bit-Array zurückgegeben.

Siehe auch „ canConvert()“ und „ convert()“.

bool QVariant::toBool() const

Gibt die Variante als bool-Wert zurück, wenn die Variante userType() Bool aufweist.

Gibt „ true “ zurück, wenn die Variante die Werte „ userType “ (), „ QMetaType::Bool “, „ QMetaType::QChar “, „ QMetaType::Double “, „ QMetaType::Int “, „ QMetaType::LongLong “, „ QMetaType::UInt “ oder „ QMetaType::ULongLong “ enthält und der Wert ungleich Null ist, oder wenn die Variante vom Typ „ QMetaType::QString “ oder „ QMetaType::QByteArray “ ist und ihr Inhalt in Kleinbuchstaben nicht zu den folgenden Werten gehört: leer, „0“ oder „false“; andernfalls wird „ false “ zurückgegeben.

Siehe auch canConvert() und convert().

QByteArray QVariant::toByteArray() const

Gibt die Variante als „ QByteArray “ zurück, wenn die Variante „ userType()“, „ QMetaType::QByteArray “ oder „ QMetaType::QString “ enthält (konvertiert mit „ QString::fromUtf8()“); andernfalls wird ein leeres Byte-Array zurückgegeben.

Siehe auch canConvert() und convert().

QChar QVariant::toChar() const

Gibt die Variante als ` QChar ` zurück, wenn die Variante die Werte ` userType()` QMetaType::QChar, ` QMetaType::Int` oder ` QMetaType::UInt` aufweist; andernfalls wird ein ungültiger ` QChar` zurückgegeben.

Siehe auch „ canConvert()“ und „ convert()“.

QDate QVariant::toDate() const

Gibt die Variante als „ QDate “ zurück, wenn die Variante „ userType()“, „ QMetaType::QDate “, „ QMetaType::QDateTime “ oder „ QMetaType::QString “ enthält; andernfalls wird ein ungültiges Datum zurückgegeben.

Wenn die Funktion ` metaType()` den Wert ` QMetaType::QString` zurückgibt, wird ein ungültiges Datum zurückgegeben, falls die Zeichenkette nicht als Datum im Format ` Qt::ISODate ` analysiert werden kann.

Siehe auch „ canConvert()“ und „ convert()“.

QDateTime QVariant::toDateTime() const

Gibt die Variante als „ QDateTime “ zurück, wenn die Variante „ userType()“, „ QMetaType::QDateTime “, „ QMetaType::QDate “ oder „ QMetaType::QString “ enthält; andernfalls wird ein ungültiges Datum/eine ungültige Uhrzeit zurückgegeben.

Wenn der Parameter ` metaType()` den Wert ` QMetaType::QString` hat, wird ein ungültiges Datum/eine ungültige Uhrzeit zurückgegeben, wenn die Zeichenfolge nicht als Datum/Uhrzeit im Format ` Qt::ISODate ` analysiert werden kann.

Siehe auch „ canConvert()“ und „ convert()“.

double QVariant::toDouble(bool *ok = nullptr) const

Gibt die Variante als Double zurück, wenn die Variante einen der folgenden Werte aufweist: userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt oder QMetaType::ULongLong; andernfalls wird 0,0 zurückgegeben.

Wenn „ ok “ nicht null ist: * „ok “ wird auf „true“ gesetzt, wenn der Wert in einen „double“-Wert konvertiert werden konnte; andernfalls * „ok “ wird auf „false“ gesetzt.

Siehe auch canConvert() und convert().

QEasingCurve QVariant::toEasingCurve() const

Gibt die Variante als „ QEasingCurve “ zurück, wenn die Variante über „ userType()“ QMetaType::QEasingCurve verfügt; andernfalls wird eine Standard-Easing-Kurve zurückgegeben.

Siehe auch ` canConvert()` und ` convert()`.

float QVariant::toFloat(bool *ok = nullptr) const

Gibt die Variante als Float zurück, wenn die Variante folgende Werte aufweist: userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt oder QMetaType::ULongLong; andernfalls wird 0,0 zurückgegeben.

Wenn „ ok “ nicht null ist: * „ok “ wird auf „true“ gesetzt, wenn der Wert in einen „double“-Wert konvertiert werden konnte; andernfalls * „ok “ wird auf „false“ gesetzt.

Siehe auch canConvert() und convert().

QHash<QString, QVariant> QVariant::toHash() const

Gibt die Variante als ` QHash` zurück: `<QString, QVariant>`, wenn die Variante über ` metaType()` QMetaType::QVariantHash verfügt. Ist dies nicht der Fall, versucht ` QVariant `, den Typ in einen Hash zu konvertieren und diesen anschließend zurückzugeben. Dies gelingt bei jedem Typ, für den ein Konverter unter ` QVariantHash ` registriert wurde oder der mithilfe von ` Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE` als assoziativer Container deklariert wurde. Trifft keine dieser Bedingungen zu, gibt diese Funktion einen leeren Hash zurück.

Siehe auch canConvert() und convert().

int QVariant::toInt(bool *ok = nullptr) const

Gibt die Variante als int zurück, wenn die Variante userType() QMetaType::Int, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt oder QMetaType::ULongLong enthält; andernfalls wird 0 zurückgegeben.

Wenn „ ok “ nicht null ist: * „ok “ wird auf „true“ gesetzt, wenn der Wert in einen „int“ konvertiert werden konnte; andernfalls * „ok “ wird auf „false“ gesetzt.

Warnung: Wenn der Wert in einen ` QMetaType::LongLong ` konvertierbar ist, aber zu groß ist, um in einem `int` dargestellt zu werden, wird der daraus resultierende arithmetische Überlauf nicht in ` ok` widergespiegelt. Eine einfache Abhilfe besteht darin, ` QString::toInt()` zu verwenden.

Siehe auch „ canConvert()“ und „ convert()“.

QJsonArray QVariant::toJsonArray() const

Gibt die Variante als „ QJsonArray “ zurück, wenn die Variante über „ userType()“ verfügt QJsonArray; andernfalls wird ein standardmäßig initialisiertes „ QJsonArray “ zurückgegeben.

Siehe auch canConvert() und convert().

QJsonDocument QVariant::toJsonDocument() const

Gibt die Variante als „ QJsonDocument “ zurück, wenn die Variante über „ userType()“ verfügt QJsonDocument; andernfalls wird ein standardmäßig konstruiertes „ QJsonDocument “ zurückgegeben.

Siehe auch canConvert() und convert().

QJsonObject QVariant::toJsonObject() const

Gibt die Variante als „ QJsonObject “ zurück, wenn die Variante „ userType()“ QJsonObject aufweist; andernfalls wird ein standardmäßig konstruiertes „ QJsonObject “ zurückgegeben.

Siehe auch canConvert() und convert().

QJsonValue QVariant::toJsonValue() const

Gibt die Variante als „ QJsonValue “ zurück, wenn die Variante über „ userType()“ verfügt QJsonValue; andernfalls wird ein standardmäßig konstruiertes „ QJsonValue “ zurückgegeben.

Siehe auch canConvert() und convert().

QLine QVariant::toLine() const

Gibt die Variante als ` QLine ` zurück, wenn die Variante ` userType()` ` QMetaType::QLine` aufweist; andernfalls wird ein ungültiges ` QLine` zurückgegeben.

Siehe auch canConvert() und convert().

QLineF QVariant::toLineF() const

Gibt die Variante als „ QLineF “ zurück, wenn die Variante „ userType()“ QMetaType::QLineF aufweist; andernfalls wird ein ungültiger „ QLineF “ zurückgegeben.

Siehe auch „ canConvert()“ und „ convert()“.

QList<QVariant> QVariant::toList() const

Gibt die Variante als „ QVariantList “ zurück, sofern die Variante über „ userType()“ QMetaType::QVariantList verfügt. Ist dies nicht der Fall, versucht „ QVariant “, den Typ in eine Liste zu konvertieren und diese anschließend zurückzugeben. Dies gelingt bei jedem Typ, für den ein Konverter unter „ QVariantList “ registriert wurde oder der mithilfe von „ Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE “ als sequenzieller Container deklariert wurde. Ist keine dieser Bedingungen erfüllt, gibt diese Funktion eine leere Liste zurück.

Siehe auch canConvert() und convert().

QLocale QVariant::toLocale() const

Gibt die Variante als „ QLocale “ zurück, wenn die Variante „ userType()“ QMetaType::QLocale aufweist; andernfalls wird ein ungültiger „ QLocale “ zurückgegeben.

Siehe auch canConvert() und convert().

qlonglong QVariant::toLongLong(bool *ok = nullptr) const

Gibt die Variante als `long long int` zurück, wenn die Variante folgende Werte aufweist: ` userType()`, ` QMetaType::LongLong`, ` QMetaType::Bool`, ` QMetaType::QByteArray`, ` QMetaType::QChar`, ` QMetaType::Double`, ` QMetaType::Int`, ` QMetaType::QString`, ` QMetaType::UInt` oder ` QMetaType::ULongLong`; andernfalls wird 0 zurückgegeben.

Wenn „ ok “ nicht null ist: „ * “ „ok “ wird auf „true“ gesetzt, wenn der Wert in einen int konvertiert werden konnte; andernfalls wird „ * “ „ok “ auf „false“ gesetzt.

Siehe auch canConvert() und convert().

QMap<QString, QVariant> QVariant::toMap() const

Gibt die Variante als „ QVariantMap “ zurück, wenn die Variante über „ metaType()“ QMetaType::QVariantMap verfügt. Ist dies nicht der Fall, versucht „ QVariant “, den Typ in eine Map zu konvertieren und diese anschließend zurückzugeben. Dies gelingt bei jedem Typ, für den ein Konverter unter „ QVariantMap “ registriert wurde oder der mithilfe von „ Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE “ als assoziativer Container deklariert wurde. Trifft keine dieser Bedingungen zu, gibt diese Funktion eine leere Map zurück.

Siehe auch canConvert() und convert().

QModelIndex QVariant::toModelIndex() const

Gibt die Variante als „ QModelIndex “ zurück, wenn die Variante über „ userType()“ QModelIndex verfügt; andernfalls wird ein standardmäßig konstruiertes „ QModelIndex “ zurückgegeben.

Siehe auch canConvert(), convert() und toPersistentModelIndex().

QPersistentModelIndex QVariant::toPersistentModelIndex() const

Gibt die Variante als ` QPersistentModelIndex ` zurück, wenn die Variante ` userType()` QPersistentModelIndex aufweist; andernfalls wird ein standardmäßig konstruiertes ` QPersistentModelIndex` zurückgegeben.

Siehe auch canConvert(), convert() und toModelIndex().

QPoint QVariant::toPoint() const

Gibt die Variante als „ QPoint “ zurück, wenn die Variante „ userType()“, „ QMetaType::QPoint “ oder „ QMetaType::QPointF “ enthält; andernfalls wird „null“ zurückgegeben: „ QPoint “.

Siehe auch „ canConvert()“ und „ convert()“.

QPointF QVariant::toPointF() const

Gibt die Variante als „ QPointF “ zurück, wenn die Variante „ userType()“, „ QMetaType::QPoint “ oder „ QMetaType::QPointF “ aufweist; andernfalls wird „null“ zurückgegeben: „ QPointF “.

Siehe auch „ canConvert()“ und „ convert()“.

qreal QVariant::toReal(bool *ok = nullptr) const

Gibt die Variante als `qreal` zurück, wenn die Variante folgende Werte aufweist: ` userType()`, ` QMetaType::Double`, ` QMetaType::Float`, ` QMetaType::Bool`, ` QMetaType::QByteArray`, ` QMetaType::Int`, ` QMetaType::LongLong`, ` QMetaType::QString`, ` QMetaType::UInt` oder ` QMetaType::ULongLong`; andernfalls wird 0,0 zurückgegeben.

Wenn „ ok “ nicht null ist: * „ok “ wird auf „true“ gesetzt, wenn der Wert in einen „double“-Wert konvertiert werden konnte; andernfalls * „ok “ wird auf „false“ gesetzt.

Siehe auch canConvert() und convert().

QRect QVariant::toRect() const

Gibt die Variante als „ QRect “ zurück, wenn die Variante „ userType()“ QMetaType::QRect aufweist; andernfalls wird ein ungültiger „ QRect “ zurückgegeben.

Siehe auch canConvert() und convert().

QRectF QVariant::toRectF() const

Gibt die Variante als „ QRectF “ zurück, wenn die Variante die Werte „ userType()“, „ QMetaType::QRect “ oder „ QMetaType::QRectF “ aufweist; andernfalls wird ein ungültiger „ QRectF “ zurückgegeben.

Siehe auch canConvert() und convert().

QRegularExpression QVariant::toRegularExpression() const

Gibt die Variante als „ QRegularExpression “ zurück, wenn die Variante „ userType()“ QRegularExpression aufweist; andernfalls wird ein leeres „ QRegularExpression “ zurückgegeben.

Siehe auch „ canConvert()“ und „ convert()“.

QSize QVariant::toSize() const

Gibt die Variante als „ QSize “ zurück, wenn die Variante „ userType()“ QMetaType::QSize aufweist; andernfalls wird ein ungültiger „ QSize “ zurückgegeben.

Siehe auch canConvert() und convert().

QSizeF QVariant::toSizeF() const

Gibt die Variante als „ QSizeF “ zurück, wenn die Variante „ userType()“ QMetaType::QSizeF aufweist; andernfalls wird ein ungültiger „ QSizeF “ zurückgegeben.

Siehe auch canConvert() und convert().

QString QVariant::toString() const

Gibt die Variante als „ QString “ zurück, wenn die Variante eine „ userType()“-Funktion enthält, darunter unter anderem:

QMetaType::QString, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::QDate, QMetaType::QDateTime, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QStringList, QMetaType::QTime, QMetaType::UInt oder QMetaType::ULongLong.

Der Aufruf von `QVariant::toString()` für eine nicht unterstützte Variante gibt eine leere Zeichenkette zurück.

Siehe auch canConvert() und convert().

QStringList QVariant::toStringList() const

Gibt die Variante als „ QStringList “ zurück, wenn die Variante „ userType()“ QMetaType::QStringList, „ QMetaType::QString “ oder „ QMetaType::QVariantList “ eines Typs enthält, der in „ QString “ konvertiert werden kann; andernfalls wird eine leere Liste zurückgegeben.

Siehe auch „ canConvert()“ und „ convert()“.

QTime QVariant::toTime() const

Gibt die Variante als „ QTime “ zurück, wenn die Variante „ userType()“, „ QMetaType::QTime “, „ QMetaType::QDateTime “ oder „ QMetaType::QString “ enthält; andernfalls wird eine ungültige Zeit zurückgegeben.

Wenn die „ metaType “()-Funktion „ QMetaType::QString “ lautet, wird eine ungültige Zeit zurückgegeben, wenn die Zeichenkette nicht als Zeit im Format „ Qt::ISODate “ geparst werden kann.

Siehe auch ` canConvert()` und ` convert()`.

uint QVariant::toUInt(bool *ok = nullptr) const

Gibt die Variante als „unsigned int“ zurück, wenn die Variante folgende Werte aufweist: userType() QMetaType::UInt, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString oder QMetaType::ULongLong; andernfalls wird 0 zurückgegeben.

Wenn „ ok “ nicht null ist: * „ok “ wird auf „true“ gesetzt, wenn der Wert in einen „unsigned int“ konvertiert werden konnte; andernfalls * „ok “ wird auf „false“ gesetzt.

Warnung: Wenn der Wert in einen „ QMetaType::ULongLong “ konvertierbar ist, aber zu groß ist, um in einem „unsigned int“ dargestellt zu werden, wird der daraus resultierende arithmetische Überlauf nicht in „ ok “ widergespiegelt. Eine einfache Abhilfe besteht darin, „ QString::toUInt()“ zu verwenden.

Siehe auch „ canConvert()“ und „ convert()“.

qulonglong QVariant::toULongLong(bool *ok = nullptr) const

Gibt die Variante als „unsigned long long int“ zurück, wenn die Variante eine der folgenden Eigenschaften aufweist: „ metaType()“, „ QMetaType::ULongLong “, „ QMetaType::Bool “, „ QMetaType::QByteArray “, „ QMetaType::QChar “, „ QMetaType::Double “, „ QMetaType::Int “, „ QMetaType::LongLong “, „ QMetaType::QString “ oder „ QMetaType::UInt “; andernfalls wird 0 zurückgegeben.

Wenn ` ok ` nicht null ist: ` * ` `ok ` wird auf `true` gesetzt, wenn der Wert in einen `int` konvertiert werden konnte; andernfalls wird ` * ` `ok ` auf `false` gesetzt.

Siehe auch canConvert() und convert().

QUrl QVariant::toUrl() const

Gibt die Variante als „ QUrl “ zurück, wenn die Variante „ userType()“ QMetaType::QUrl aufweist; andernfalls wird ein ungültiger „ QUrl “ zurückgegeben.

Siehe auch canConvert() und convert().

QUuid QVariant::toUuid() const

Gibt die Variante als „ QUuid “ zurück, wenn die Variante „ metaType()“, „ QMetaType::QUuid “, „ QMetaType::QByteArray “ oder „ QMetaType::QString “ aufweist; andernfalls wird ein standardmäßig konstruiertes „ QUuid “ zurückgegeben.

Siehe auch ` canConvert()` und ` convert()`.

Gibt den Speichertyp des in der Variante gespeicherten Werts zurück. Dies entspricht dem Ergebnis von „ metaType() .id()“.

Siehe auch ` metaType()`.

const char *QVariant::typeName() const

Gibt den Namen des in der Variante gespeicherten Typs zurück. Die zurückgegebenen Zeichenfolgen beschreiben den C++-Datentyp, der zum Speichern der Daten verwendet wird: zum Beispiel „QFont “, „QString “ oder „QVariantList “. Eine ungültige Variante gibt 0 zurück.

template <typename T> T QVariant::value() const &

Gibt den gespeicherten Wert zurück, der in den Vorlagentyp „ T “ konvertiert wurde. Rufen Sie „ canConvert()“ auf, um festzustellen, ob ein Typ konvertiert werden kann. Kann der Wert nicht konvertiert werden, wird ein standardmäßig konstruierter Wert zurückgegeben.

Wenn der Typ „ T “ von „ QVariant “ unterstützt wird, verhält sich diese Funktion genau wie „ toString()“, „ toInt()“ usw.

Beispiel:

QVariant v;

MyCustomStruct c;
if (v.canConvert<MyCustomStruct>())
    c = v.value<MyCustomStruct>();

v = 7;
int i = v.value<int>();                        // same as v.toInt()
QString s = v.value<QString>();                // same as v.toString(), s is now "7"
MyCustomStruct c2 = v.value<MyCustomStruct>(); // conversion failed, c2 is empty

Wenn der Typ „ QVariant “ einen Zeiger auf einen von „ QObject “ abgeleiteten Typ enthält, kann „ T “ ein beliebiger Typ vom Typ „ QObject “ sein. Wenn der in „ QVariant “ gespeicherte Zeiger auf „ qobject_cast “ zu „T“ verweisen kann, wird dieses Ergebnis zurückgegeben. Andernfalls wird „ nullptr “ zurückgegeben. Beachten Sie, dass dies nur für Unterklassen von „ QObject “ funktioniert, die das Makro „ Q_OBJECT “ verwenden.

Wenn der ` QVariant ` einen sequenziellen Container enthält und ` T ` den Wert ` QVariantList` hat, werden die Elemente des Containers in ` QVariant`-Objekte konvertiert und als ` QVariantList` zurückgegeben.

QList<int> intList = {7, 11, 42};

QVariant variant = QVariant::fromValue(intList);
if (variant.canConvert<QVariantList>()) {
    QMetaSequence::Iterable iterable = variant.value<QMetaSequence::Iterable>();
    // Man kann die C++11-Range-for-Schleife verwenden:
    for (const QVariant&v: iterable) {
        qDebug() << v;
    }
    // Iteratoren können verwendet werden:
    QMetaSequence::Iterable::const_iteratorit = iterable.begin();
    const QMetaSequence::Iterable::const_iteratorend = iterable.end();
    for ( ; it != end;++it) {
        qDebug() << *it;
    }
}

Siehe auch setValue(), fromValue(), canConvert() und Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE().

template <typename T> T QVariant::view()

Gibt eine veränderbare Ansicht vom Template-Typ „ T “ für den gespeicherten Wert zurück. Rufen Sie ` canView()` auf, um festzustellen, ob eine solche Ansicht unterstützt wird. Kann keine solche Ansicht erstellt werden, wird der gespeicherte Wert zurückgegeben, der in den Template-Typ ` T` konvertiert wurde. Rufen Sie ` canConvert()` auf, um festzustellen, ob ein Typ konvertiert werden kann. Kann der Wert weder als Ansicht dargestellt noch konvertiert werden, wird ein standardmäßig konstruierter Wert zurückgegeben.

Siehe auch „ canView()“ und „ Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE()“.

[noexcept] QVariant &QVariant::operator=(QVariant &&other)

Weist „ other “ dieser „ QVariant “-Instanz zu.

QVariant &QVariant::operator=(const QVariant &variant)

Weist dieser Variante den Wert der Variante „ variant “ zu.