QMetaType Class

Dokumentation der Mitgliedsfunktionen

[constexpr noexcept default, since 6.0] QMetaType::QMetaType()

Erstellt ein standardmäßiges, ungültiges QMetaType-Objekt.

Diese Funktion wurde in Qt 6.0 eingeführt.

[explicit] QMetaType::QMetaType(int typeId)

Erstellt ein QMetaType-Objekt, das alle Informationen zum Typ „ typeId “ enthält.

[constexpr, since 6.0] qsizetype QMetaType::alignOf() const

Gibt die Ausrichtung des Typs in Bytes zurück (d. h. `alignof(T)`, wobei `T` der tatsächliche Typ ist, für den diese ` QMetaType `-Instanz erstellt wurde).

Diese Funktion wird typischerweise zusammen mit ` construct()` verwendet, um die Speicherverwaltung eines Typs auf niedriger Ebene durchzuführen.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch „ QMetaType::construct()“ und „ QMetaType::sizeOf()“.

[static] bool QMetaType::canConvert(QMetaType fromType, QMetaType toType)

Gibt „ true “ zurück, wenn „ QMetaType::convert “ die Konvertierung von „ fromType “ nach „ toType “ durchführen kann. Beachten Sie, dass es hierbei hauptsächlich um die Möglichkeit zur Durchführung der Konvertierung geht, während die eigentliche Konvertierung beim Versuch fehlschlagen kann (beispielsweise bei der Konvertierung eines Gleitkommawerts in eine Ganzzahl außerhalb ihres Bereichs).

Die Funktion ` registerConverter()` kann verwendet werden, um zusätzliche Konvertierungen zu registrieren, entweder zwischen einem integrierten und einem nicht integrierten Typ oder zwischen zwei nicht integrierten Typen. Diese Funktion gibt ` true ` zurück, wenn der Konvertierungspfad registriert ist.

Die folgenden Konvertierungen werden von Qt unterstützt:

Zu den weiteren unterstützten Konvertierungen gehören solche zwischen allen primitiven Typen (int, float, bool usw., einschließlich aller Enumerationen) sowie zwischen beliebigen Zeigertypen und std::nullptr_t. Enumerationen können zudem in QString und QByteArray konvertiert werden.

Wenn sowohl ` fromType ` als auch ` toType ` Typen sind, die von ` QObject ` abgeleitet sind (oder Zeiger darauf), gibt diese Funktion ebenfalls ` true ` zurück, sofern einer der Typen vom anderen abgeleitet ist. Das heißt, sie gibt `true` zurück, wenn ein ` static_cast<> ` vom durch ` fromType ` beschriebenen Typ zum durch ` toType ` beschriebenen Typ kompilierbar wäre. Die Funktion ` convert()` funktioniert wie ` qobject_cast()` und überprüft den dynamischen Typ des Objekts, auf das der ` QVariant` zeigt.

Ein Typumwandlung aus einem sequenziellen Container liefert für diese Funktion ebenfalls „true“, wenn der toType der QVariantList ist.

Ebenso liefert ein Typumwandlung aus einem assoziativen Container für diese Funktion den Wert „true“, wenn der „ toType “ entweder „ QVariantHash “ oder „ QVariantMap “ ist.

Siehe auch „ convert()“, „ QMetaSequence::Iterable “, „ Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE()“, „ QMetaAssociation::Iterable “ und „ Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE()“.

[static] bool QMetaType::canView(QMetaType fromType, QMetaType toType)

Gibt „ true “ zurück, wenn „ QMetaType::view “ eine veränderbare Ansicht vom Typ „ toType “ für den Typ „ fromType “ erstellen kann.

Die Konvertierung zwischen Zeigern von Typen, die von QObject abgeleitet sind, gibt für diese Funktion „true“ zurück, wenn eine qobject_cast vom durch fromType beschriebenen Typ zum durch toType beschriebenen Typ erfolgreich wäre.

Sie können eine veränderbare Ansicht vom Typ „ QMetaSequence::Iterable “ für jeden Container erstellen, der mit „ Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE()“ registriert wurde.

Ebenso können Sie eine veränderbare Ansicht vom Typ QMetaAssociation::Iterable für jeden Container erstellen, der bei Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE() registriert ist.

Siehe auch convert(), QMetaSequence::Iterable, Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(), QMetaAssociation::Iterable sowie Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE().

[since 6.0] QPartialOrdering QMetaType::compare(const void *lhs, const void *rhs) const

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.

Beide Objekte müssen von dem durch diesen Metatyp beschriebenen Typ sein. Wenn entweder lhs oder rhs den Wert nullptr hat, sind die Werte ungeordnet. Ein Vergleich wird nur unterstützt, wenn der „kleiner als“-Operator des Typs für die Metatyp-Deklaration sichtbar war.

War auch der Gleichheitsoperator des Typs sichtbar, gelten Werte nur dann als gleich, wenn der Gleichheitsoperator dies angibt. Fehlt ein Gleichheitsoperator und ist keiner der Werte kleiner als der andere, gelten die Werte als gleich; ist ein Gleichheitsoperator vorhanden und sind zwei solche Werte nicht gleich, gelten sie als ungeordnet, genau wie NaN-Werte (Not a Number) eines Gleitkomma-Typs, die außerhalb seiner Ordnung liegen.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch equals() und isOrdered().

void *QMetaType::construct(void *where, const void *copy = nullptr) const

Erstellt einen Wert des Typs, für den diese ` QMetaType `-Instanz erstellt wurde, im vorhandenen Speicher, auf den ` where` verweist – das heißt, eine Kopie von ` copy` – und gibt ` where` zurück. Ist ` copy ` gleich Null, wird der Wert standardmäßig initialisiert.

Dies ist eine Low-Level-Funktion zur expliziten Verwaltung des Speichers, der zum Speichern des Typs verwendet wird. Ziehen Sie den Aufruf von ` create()` in Betracht, wenn Sie diese Ebene der Kontrolle nicht benötigen (d. h., verwenden Sie „new“ anstelle von „placement new“).

Sie müssen sicherstellen, dass where auf einen Speicherort verweist, an dem der neue Wert gespeichert werden kann, und dass where entsprechend ausgerichtet ist. Die Größe des Typs kann durch Aufruf von sizeOf() abgefragt werden.

Als Faustregel für die Ausrichtung gilt, dass ein Typ an seiner natürlichen Grenze ausgerichtet wird, d. h. an der kleinsten Potenz von 2, die größer ist als der Typ selbst, es sei denn, diese Ausrichtung ist größer als die maximale nutzbare Ausrichtung für die Plattform. In der Praxis ist ein Ausrichtungswert, der größer als 2 * sizeof(void*) ist, nur für spezielle Hardware-Befehle erforderlich (z. B. ausgerichtete SSE-Lade- und Speicherbefehle auf x86).

[static] bool QMetaType::convert(QMetaType fromType, const void *from, QMetaType toType, void *to)

Konvertiert das Objekt unter from von fromType in den vorab zugewiesenen Speicherbereich unter to vom Typ toType. Gibt true zurück, wenn die Konvertierung erfolgreich war, andernfalls false.

Sowohl ` from ` als auch ` to ` müssen gültige Zeiger sein.

void *QMetaType::create(const void *copy = nullptr) const

Gibt eine Kopie von ` copy` zurück, vorausgesetzt, es handelt sich um den Typ, für den diese ` QMetaType `-Instanz erstellt wurde. Wenn ` copy ` gleich ` nullptr` ist, wird eine Instanz mit Standardkonstruktion erstellt.

Siehe auch ` QMetaType::destroy()`.

bool QMetaType::debugStream(QDebug &dbg, const void *rhs)

Leitet das Objekt unter rhs in den Debug-Stream dbg weiter. Gibt bei Erfolg true zurück, andernfalls false.

void QMetaType::destroy(void *data) const

Löscht die ` data`, vorausgesetzt, es handelt sich um den Typ, für den diese ` QMetaType `-Instanz erstellt wurde.

Siehe auch QMetaType::create().

void QMetaType::destruct(void *data) const

Löscht den Wert unter data, vorausgesetzt, er ist vom Typ, für den diese QMetaType -Instanz erstellt wurde.

Im Gegensatz zu ` destroy()` ruft diese Funktion nur den Destruktor des Typs auf, nicht jedoch den `delete`-Operator.

Siehe auch ` QMetaType::construct()`.

[since 6.0] bool QMetaType::equals(const void *lhs, const void *rhs) const

Vergleicht die Objekte unter lhs und rhs auf Gleichheit.

Beide Objekte müssen von dem durch diesen Metatyp beschriebenen Typ sein. Die beiden Objekte können nur verglichen werden, wenn ein „kleiner als“- oder Gleichheitsoperator für den Typ in der Metatyp-Deklaration sichtbar war. Andernfalls betrachtet der Metatyp die Werte niemals als gleich. War ein Gleichheitsoperator für die Metatyp-Deklaration sichtbar, ist dieser maßgebend; andernfalls, wenn der „kleiner-als“-Operator sichtbar ist und keiner der Werte kleiner als der andere ist, werden die beiden als gleich angesehen. Sind die Werte ungeordnet (siehe compare() für Details), sind sie nicht gleich.

Gibt „true“ zurück, wenn die beiden Objekte gleich sind, andernfalls „false“.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch isEqualityComparable() und compare().

[constexpr] QMetaType::TypeFlags QMetaType::flags() const

Gibt Flags des Typs zurück, für den diese Instanz von ` QMetaType ` erstellt wurde. Um bestimmte Typmerkmale zu überprüfen, sollten Sie lieber eine der „is-“Funktionen verwenden, anstatt direkt auf die Flags zurückzugreifen.

Siehe auch QMetaType::TypeFlags, isDefaultConstructible(), isCopyConstructible(), isMoveConstructible(), isDestructible(), isEqualityComparable() und isOrdered().

[static] QMetaType QMetaType::fromName(QByteArrayView typeName)

Gibt ein ` QMetaType ` zurück, das mit ` typeName` übereinstimmt. Das zurückgegebene Objekt ist ungültig, wenn der `typeName` nicht bekannt ist. QMetaType

[static constexpr] template <typename T> QMetaType QMetaType::fromType()

Gibt das „ QMetaType “ zurück, das dem Typ im Vorlagenparameter entspricht.

[static] bool QMetaType::hasRegisteredConverterFunction(QMetaType fromType, QMetaType toType)

Gibt „ true “ zurück, wenn das Metatyp-System eine registrierte Konvertierung von der Metatyp-ID „ fromType “ zu toType

[static] template <typename From, typename To> bool QMetaType::hasRegisteredConverterFunction()

Gibt „ true “ zurück, wenn das Metatyp-System eine registrierte Konvertierung vom Typ „From“ zum Typ „To“ enthält.

[since 6.1] bool QMetaType::hasRegisteredDataStreamOperators() const

Gibt „ true “ zurück, wenn das Metatyp-System Datenstromoperatoren für diesen Metatyp registriert hat.

Diese Funktion wurde in Qt 6.1 eingeführt.

[since 6.0] bool QMetaType::hasRegisteredDebugStreamOperator() const

Gibt „ true “ zurück, wenn das Metatyp-System einen registrierten Debug-Stream-Operator für diesen Metatyp besitzt.

Diese Funktion wurde in Qt 6.0 eingeführt.

[static] bool QMetaType::hasRegisteredMutableViewFunction(QMetaType fromType, QMetaType toType)

Gibt „ true “ zurück, wenn das Metatyp-System eine registrierte veränderbare Ansicht mit der Metatyp-ID „ fromType “ des Metatyps mit der ID „ toType “ enthält.

[static, since 6.0] template <typename From, typename To> bool QMetaType::hasRegisteredMutableViewFunction()

Gibt „ true “ zurück, wenn das Metatyp-System eine registrierte veränderbare Ansicht vom Typ „From“ auf dem Typ „To“ besitzt.

Diese Funktion wurde in Qt 6.0 eingeführt.

int QMetaType::id() const

Gibt den ID-Typ zurück, den diese „ QMetaType “-Instanz enthält.

[noexcept, since 6.5] bool QMetaType::isCopyConstructible() const

Gibt „true“ zurück, wenn dieser Typ per Kopierkonstruktion instanziiert werden kann. Ist dies der Fall, können die Funktionen „ construct()“ und „ create()“ mit einem nicht-null-Wert für den Parameter „ copy “ verwendet werden.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch ` flags()`, ` isDefaultConstructible()`, ` isMoveConstructible()` und ` isDestructible()`.

[noexcept, since 6.5] bool QMetaType::isDefaultConstructible() const

Gibt „true“ zurück, wenn dieser Typ per Standardkonstruktion initialisiert werden kann. Ist dies der Fall, können die Funktionen „ construct()“ und „ create()“ mit einem Parameter „ copy “ verwendet werden, dessen Wert „null“ ist.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch flags(), isCopyConstructible(), isMoveConstructible() und isDestructible().

[noexcept, since 6.5] bool QMetaType::isDestructible() const

Gibt „true“ zurück, wenn dieser Typ zerstört werden kann. Ist dies der Fall, können die Funktionen „ destroy()“ und „ destruct()“ aufgerufen werden.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch flags(), isDefaultConstructible(), isCopyConstructible() und isMoveConstructible().

bool QMetaType::isEqualityComparable() const

Gibt „ true “ zurück, wenn ein „kleiner als“- oder Gleichheitsoperator für den durch diesen Metatyp beschriebenen Typ in der Metatyp-Deklaration sichtbar war; andernfalls „ false “.

Siehe auch „ equals()“ und „ isOrdered()“.

[noexcept, since 6.5] bool QMetaType::isMoveConstructible() const

Gibt „true“ zurück, wenn dieser Typ per Move-Konstruktion instanziiert werden kann. „ QMetaType “ verfügt derzeit nicht über eine API, um dieses Merkmal zu nutzen.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch flags(), isDefaultConstructible(), isCopyConstructible() und isDestructible().

bool QMetaType::isOrdered() const

Gibt „ true “ zurück, wenn ein „kleiner als“-Operator für den durch diesen Metatyp beschriebenen Typ in der Metatyp-Deklaration sichtbar war; andernfalls „ false “.

Siehe auch „ compare()“ und „ isEqualityComparable()“.

[noexcept] bool QMetaType::isRegistered() const

Gibt „ true “ zurück, wenn dieses „ QMetaType “-Objekt in der globalen Metatyp-Registrierung von Qt registriert wurde. Durch die Registrierung kann der Typ anhand seines Namens (mit „ QMetaType::fromName()“) oder anhand seiner ID (mit dem Konstruktor) gefunden werden.

Siehe auch qRegisterMetaType() und isValid().

[static] bool QMetaType::isRegistered(int type)

Gibt „ true “ zurück, wenn der Datentyp mit der ID „ type “ registriert ist; andernfalls wird „ false “ zurückgegeben.

Siehe auch type() und Type.

[constexpr noexcept] bool QMetaType::isValid() const

Gibt „ true “ zurück, wenn dieses „ QMetaType “-Objekt gültige Informationen zu einem Typ enthält, andernfalls „false“.

Siehe auch ` isRegistered()`.

bool QMetaType::load(QDataStream &stream, void *data) const

Liest das Objekt dieses Typs aus der angegebenen Datei „ stream “ in die Datei „ data “ ein. Gibt „ true “ zurück, wenn das Objekt erfolgreich geladen wurde; andernfalls wird „ false “ zurückgegeben.

Normalerweise sollten Sie diese Funktion nicht direkt aufrufen müssen. Verwenden Sie stattdessen die Methode ` operator>>()` von ` QVariant`, die auf `load()` zurückgreift, um benutzerdefinierte Typen zu laden.

Siehe auch save().

[constexpr] const QMetaObject *QMetaType::metaObject() const

Gibt einen „ QMetaObject “ zurück, der diesem Typ zugeordnet ist.

Ist der Typ ein Zeigertyp auf eine Unterklasse von ` QObject`, enthält ` flags()` ` QMetaType::PointerToQObject ` und diese Funktion gibt das entsprechende ` QMetaObject` zurück. Dies kann in Kombination mit ` QMetaObject::newInstance()` verwendet werden, um `QObjects` dieses Typs zu erstellen.

Ist der Typ ein „ Q_GADGET “, enthält „ flags()“ „ QMetaType::IsGadget “. Ist der Typ ein Zeiger auf ein „ Q_GADGET “, enthält „ flags()“ „ QMetaType::PointerToGadget “. In beiden Fällen gibt diese Funktion ihren „ QMetaObject “ zurück. Dies kann verwendet werden, um „ QMetaMethod “ und „ QMetaProperty “ abzurufen und sie beispielsweise auf einen Zeiger dieses Typs anzuwenden, wie durch „ QVariant::data()“ vorgegeben.

Wenn es sich bei dem Typ um eine Aufzählung handelt, enthält ` flags()` ` QMetaType::IsEnumeration`. In diesem Fall gibt diese Funktion die ` QMetaObject ` des umschließenden Objekts zurück, wenn die Aufzählung als ` Q_ENUM ` registriert wurde, andernfalls ` nullptr `.

Siehe auch QMetaType::flags().

[constexpr] const char *QMetaType::name() const

Gibt den Typnamen zurück, der diesem ` QMetaType` zugeordnet ist, oder einen Nullzeiger, falls kein passender Typ gefunden wurde. Der zurückgegebene Zeiger darf nicht gelöscht werden.

Siehe auch ` typeName()`.

[static] template <typename From, typename To> bool QMetaType::registerConverter()

Registriert die Möglichkeit einer impliziten Konvertierung vom Typ „From“ zum Typ „To“ im Metatyp-System. Gibt „ true “ zurück, wenn die Registrierung erfolgreich war, andernfalls „false“.

class Counter {
  int number = 0;
public:
  int value() const { return number; }
  operator int() const { return value(); }
  void increment() {++number;}
};
QMetaType::registerConverter<Counter, int>();

[static] template <typename From, typename To> bool QMetaType::registerConverter(To (From::*function)() const)

Registriert eine Methode „ function “ wie „To From::function() const“ als Konverter vom Typ „From“ zum Typ „To“ im Metatyp-System. Gibt „ true “ zurück, wenn die Registrierung erfolgreich war, andernfalls „false“.

struct Coordinates {
  int x;
  int y;
  int z;

  QString toString() const { return u"[x: %1; y: %2, z: %3]"_s.arg(QString::number(x),
    QString::number(y),
    QString::number(z)); }
};
QMetaType::registerConverter<Coordinates, QString>(&Coordinates::toString);

[static] template <typename From, typename To> bool QMetaType::registerConverter(To (From::*function)(bool *) const)

Registriert eine Methode „ function “ wie „To From::function(bool *ok) const“ als Konverter vom Typ „From“ zum Typ „To“ im Metatyp-System. Gibt „ true “ zurück, wenn die Registrierung erfolgreich war, andernfalls „false“.

Der Zeiger ` ok ` kann von der Funktion verwendet werden, um anzugeben, ob die Konvertierung erfolgreich war.

struct BigNumber {
    long long l;

    int toInt(bool *ok = nullptr) const {
      const bool canConvertSafely = l < std::numeric_limits<int>::max();
      if (ok)
        *ok = canConvertSafely;
      return l;
    }
};
QMetaType::registerConverter<BigNumber, int>(&BigNumber::toInt);

[static] template < typename From, typename To, typename UnaryFunction > bool QMetaType::registerConverter(UnaryFunction function)

Registriert ein unäres Funktionsobjekt function als Konverter vom Typ „From“ zum Typ „To“ im Metatyp-System. Gibt true zurück, wenn die Registrierung erfolgreich war, andernfalls false.

function Muss eine Instanz vom Typ „ From “ entgegennehmen und eine Instanz vom Typ „ To “ zurückgeben. Es kann sich um einen Funktionszeiger, ein Lambda oder ein Funktor-Objekt handeln. Seit Qt 6.5 kann die Funktion „ function “ auch eine Instanz vom Typ „ std::optional<To> “ zurückgeben, um fehlgeschlagene Konvertierungen anzuzeigen.

QMetaType::registerConverter<CustomStringType, QString>([](const CustomStringType &str) {
    return QString::fromUtf8(str.data());
});
QMetaType::registerConverter<QJsonValue, CustomPointType>(
          [](const QJsonValue &value) -> std::optional<CustomPointType> {
    const auto object = value.toObject();
    if (!object.contains("x") || !object.contains("y"))
        return std::nullopt;  // The conversion fails if the required properties are missing
    return CustomPointType{object["x"].toDouble(), object["y"].toDouble()};
});

[static, since 6.0] template <typename From, typename To> bool QMetaType::registerMutableView(To (From::*function)())

Registriert eine Methode „ function “ wie „ To From::function() “ als veränderbare Ansicht vom Typ „ To “ auf dem Typ „ From “ im Metatyp-System. Gibt „ true “ zurück, wenn die Registrierung erfolgreich war, andernfalls „ false “.

Diese Funktion wurde in Qt 6.0 eingeführt.

[static, since 6.0] template < typename From, typename To, typename UnaryFunction > bool QMetaType::registerMutableView(UnaryFunction function)

Registriert ein unäres Funktionsobjekt „ function “ als veränderbare Ansicht vom Typ „To“ auf dem Typ „From“ im Metatyp-System. Gibt „ true “ zurück, wenn die Registrierung erfolgreich war, andernfalls „ false “.

Diese Funktion wurde in Qt 6.0 eingeführt.

[since 6.5] void QMetaType::registerType() const

Registriert diese „ QMetaType “ in der Typenregistrierung, sodass sie anhand ihres Namens über „ QMetaType::fromName()“ gefunden werden kann.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch ` qRegisterMetaType()`.

bool QMetaType::save(QDataStream &stream, const void *data) const

Schreibt das Objekt, auf das data verweist, in die angegebene stream. Gibt true zurück, wenn das Objekt erfolgreich gespeichert wurde; andernfalls wird false zurückgegeben.

Normalerweise sollten Sie diese Funktion nicht direkt aufrufen müssen. Verwenden Sie stattdessen die Methode „ operator<<() “ von „ QVariant “, die sich auf „save()“ stützt, um benutzerdefinierte Typen zu streamen.

Siehe auch „ load()“.

[constexpr] qsizetype QMetaType::sizeOf() const

Gibt die Größe des Typs in Byte zurück (d. h. `sizeof(T)`, wobei `T` der tatsächliche Typ ist, für den diese ` QMetaType `-Instanz erstellt wurde).

Diese Funktion wird typischerweise zusammen mit ` construct()` verwendet, um die Speicherverwaltung eines Typs auf niedriger Ebene durchzuführen.

Siehe auch ` QMetaType::construct()` und ` QMetaType::alignOf()`.

[since 6.6] QMetaType QMetaType::underlyingType() const

Wenn dieser Metatyp eine Aufzählung darstellt, gibt diese Methode einen Metatyp einer numerischen Klasse zurück, deren Vorzeichen und Größe mit denen des zugrunde liegenden Typs der Aufzählung übereinstimmen. Wenn er einen Typ vom Typ „ QFlags “ darstellt, gibt er „ QMetaType::Int “ zurück. In allen anderen Fällen wird ein ungültiger „ QMetaType “ zurückgegeben.

Diese Funktion wurde in Qt 6.6 eingeführt.

[static, since 6.0] bool QMetaType::view(QMetaType fromType, void *from, QMetaType toType, void *to)

Erstellt eine veränderbare Ansicht des Objekts unter from von fromType im vorab zugewiesenen Speicherbereich unter to vom Typ toType. Gibt true zurück, wenn die Konvertierung erfolgreich war, andernfalls false.

Diese Funktion wurde in Qt 6.0 eingeführt.