QVariant Class

Documentation sur les fonctions membres

[noexcept] QVariant::QVariant()

Crée une variante non valide.

[noexcept] QVariant::QVariant(QChar c)

Crée une nouvelle variante avec une valeur de type char, c.

QVariant::QVariant(const QPersistentModelIndex &val)

Crée une nouvelle variante avec une valeur « QPersistentModelIndex », val.

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

Crée une nouvelle variante avec la valeur d'expression régulière « re ».

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

Crée une nouvelle variante avec une valeur de type chaîne de caractères : val.

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

Crée une nouvelle variante avec une valeur de type liste de chaînes de caractères, val.

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

Crée une nouvelle variante dont la valeur « url » est val.

QVariant::QVariant(const char *val)

Crée une nouvelle variante dont la valeur de chaîne est « val ». La variante effectue une copie profonde de « val » dans « QString », en supposant que le codage de la chaîne d’entrée « val » est UTF-8.

Notez que val est converti en QString pour être stocké dans la variante et que QVariant::userType() renverra QMetaType::QString pour la variante.

Vous pouvez désactiver cet opérateur en définissant QT_NO_CAST_FROM_ASCII lors de la compilation de vos applications.

[noexcept] QVariant::QVariant(double val)

Crée une nouvelle variante avec une valeur à virgule flottante : val.

[noexcept] QVariant::QVariant(float val)

Crée une nouvelle variante contenant une valeur à virgule flottante : val.

[noexcept] QVariant::QVariant(int val)

Crée une nouvelle variante avec une valeur entière, val.

[noexcept] QVariant::QVariant(qlonglong val)

Crée une nouvelle variante avec une valeur de type « long long », val.

[noexcept] QVariant::QVariant(qulonglong val)

Crée une nouvelle variante avec une valeur entière de type « unsigned long long », val.

[noexcept] QVariant::QVariant(uint val)

Crée une nouvelle variante avec une valeur entière non signée, de type ` val`.

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

Construit une variante de type type et l'initialise avec une copie de *copy si copy n'est pas nullptr (auquel cas, copy doit pointer vers un objet de type type).

Notez que vous devez passer l’adresse de l’objet que vous souhaitez stocker.

En règle générale, vous n’avez jamais besoin d’utiliser ce constructeur ; utilisez plutôt QVariant::fromValue() pour construire des variantes à partir des types de pointeurs représentés par QMetaType::VoidStar et QMetaType::QObjectStar.

Si type ne prend pas en charge la construction par copie et que copy n’est pas nullptr, la variante sera invalide. De même, si copy est nullptr et que type ne prend pas en charge la construction par défaut, la variante sera invalide.

Voir également QVariant::fromMetaType, QVariant::fromValue() et QMetaType::Type.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

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

Cette fonction a été introduite dans Qt 6.12.

[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)

Construit une nouvelle variante contenant une valeur de type ` T`. La valeur contenue est initialisée avec les arguments ` std::forward<Args>(args)...`.

Ce constructeur est fourni à des fins de compatibilité avec STL/std::any.

Contraintes

Ne participe à la résolution des surcharges que si ` T ` peut être construit à partir de ` args`.

Cette fonction a été introduite dans Qt 6.6.

[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)

Cette surcharge a pour but de prendre en charge les types dont les constructeurs acceptent une liste d'initializer_list. Son comportement est par ailleurs équivalent à celui de la surcharge « in_place_type_t » sans liste d'initialisation.

Cette fonction a été introduite dans Qt 6.6.

[noexcept] QVariant::QVariant(QDate val)

Crée une nouvelle variante avec une valeur de date, val.

QVariant::QVariant(QLatin1StringView val)

Crée une nouvelle variante avec une valeur « QString » à partir de la chaîne Latin-1 consultée via val.

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

Crée une nouvelle variante dont la valeur de ligne est val.

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

Crée une nouvelle variante dont la valeur de ligne est val.

[noexcept] QVariant::QVariant(QPoint val)

Crée une nouvelle variante dont la valeur ponctuelle est « val ».

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

Crée une nouvelle variante dont la valeur ponctuelle est val.

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

Crée une nouvelle variante dont la valeur rect est val.

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

Crée une nouvelle variante dont la valeur rect est val.

[noexcept] QVariant::QVariant(QSize val)

Crée une nouvelle variante dont la valeur de taille est « val ».

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

Crée une nouvelle variante dont la taille est définie par val.

[noexcept] QVariant::QVariant(QTime val)

Crée une nouvelle variante avec une valeur temporelle : val.

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

Crée une nouvelle variante avec une valeur UUID, 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)

Construit par défaut une instance de ` QVariant`. Cette fonction est supprimée.

[noexcept] QVariant::QVariant(bool val)

Crée une nouvelle variante avec une valeur booléenne : « val ».

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

Crée une nouvelle variante avec une valeur de type « bitarray », val.

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

Crée une nouvelle variante avec une valeur de type « bytearray », val.

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

Crée une nouvelle variante avec une valeur de date et d'heure, val.

QVariant::QVariant(const QEasingCurve &val)

Crée une nouvelle variante avec une valeur de courbe d'accélération, val.

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

Crée une nouvelle variante à partir d'un hachage d'QVariants, val.

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

Crée une nouvelle variante avec une valeur de type tableau JSON : val.

QVariant::QVariant(const QJsonDocument &val)

Crée une nouvelle variante avec une valeur de type document JSON, val.

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

Crée une nouvelle variante avec une valeur de type objet JSON, val.

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

Crée une nouvelle variante avec une valeur JSON, val.

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

Crée une nouvelle variante avec une valeur de type liste, val.

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

Crée une nouvelle variante avec la valeur de paramètres régionaux suivante : l.

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

Crée une nouvelle variante avec une carte de l'QVariant, val.

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

Crée une nouvelle variante avec une valeur de type « QModelIndex », val.

QVariant::QVariant(const QVariant &p)

Crée une copie de la variante « p » transmise en argument à ce constructeur.

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

La fonction « move » construit une instance de `QVariant`, de sorte qu'elle pointe vers le même objet que celui vers lequel pointait ` other `.

[noexcept] QVariant::~QVariant()

Supprime l'QVariant e et l'objet qu'il contient.

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

Renvoie « true » si la variante peut être convertie en type de modèle « T », sinon « false ».

Exemple :

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

Un ` QVariant ` contenant un pointeur vers un type dérivé de ` QObject ` renverra également `true` pour cette fonction si une ` qobject_cast ` vers le type de modèle ` T ` aboutissait. Notez que cela ne fonctionne que pour les sous-classes de ` QObject ` qui utilisent la macro ` Q_OBJECT `.

Voir également convert().

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

Renvoie « true » si le type de la variante peut être converti vers le type demandé, « type ». Une telle conversion s'effectue automatiquement lors de l'appel des méthodes toInt(), toBool(), etc.

Notez que cette fonction opère uniquement sur le type de la variante, et non sur son contenu. Elle indique s’il existe un chemin de conversion de cette variante vers type, et non que la conversion aboutira si elle est tentée.

Cette fonction a été introduite dans Qt 6.0.

Voir également QMetaType::canConvert().

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

Renvoie « true » si une vue modifiable du type de modèle « T » peut être créée sur cette variante ; sinon, renvoie « false ».

Voir également value().

void QVariant::clear()

Convertissez cette variante en type « QMetaType::UnknownType » et libérez toutes les ressources utilisées.

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

Compare les objets disponibles à l'adresse lhs et rhs afin de déterminer leur ordre.

Renvoie QPartialOrdering::Unordered si la comparaison n’est pas prise en charge ou si les valeurs ne sont pas ordonnées. Sinon, renvoie QPartialOrdering::Less, QPartialOrdering::Equivalent ou QPartialOrdering::Greater si lhs est respectivement inférieur, égal ou supérieur à rhs.

Si les variantes contiennent des données de métatypes différents, les valeurs sont considérées comme non ordonnées, sauf si elles sont toutes deux de type numérique ou pointeur, auquel cas les règles habituelles de comparaison numérique ou de pointeurs s’appliquent.

Si les deux variantes contiennent des données de même métatype, la méthode utilise la méthode ` QMetaType::compare ` pour déterminer l’ordre des deux variantes, ce qui peut également indiquer qu’elle ne parvient pas à établir un ordre entre les deux valeurs.

Cette fonction a été introduite dans Qt 6.0.

Voir également ` QMetaType::compare()` et ` QMetaType::isOrdered()`.

Renvoie un pointeur vers l'objet contenu sous la forme d'un *void* générique sur lequel il n'est pas possible d'écrire.

Voir également get_if() et QMetaType.

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

Effectue un transtypage de la variante vers le type demandé, targetType. Si le transtypage échoue, la variante est tout de même convertie au type demandé, mais elle est laissée dans un état nul (vidé), similaire à celui généré par QVariant(Type).

Renvoie ` true ` si la conversion du type actuel de la variante a réussi ; sinon, renvoie ` false`.

Un ` QVariant ` contenant un pointeur vers un type dérivé de ` QObject ` sera également converti et renverra `true` pour cette fonction si une ` qobject_cast ` vers le type décrit par ` targetType ` aboutissait. Notez que cela ne fonctionne que pour les sous-classes de ` QObject ` qui utilisent la macro ` Q_OBJECT `.

Cette fonction a été introduite dans Qt 6.0.

Voir également canConvert() et clear().

void *QVariant::data()

Renvoie un pointeur vers l'objet contenu sous la forme d'un *void* générique sur lequel il est possible d'écrire.

Cette fonction détache l'QVariant. Lorsqu'elle est appelée sur un null-QVariant, l'QVariant ne sera pas nul après l'appel.

Voir également get_if() et QMetaType.

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

Remplace l'objet actuellement stocké dans ` *this ` par un objet de type ` T`, construit à partir de ` args ` et `...`. Si ` *this ` n'était pas nul, l'objet précédemment stocké est d'abord détruit. Si possible, cette méthode réutilise la mémoire allouée par ` QVariant`. Renvoie une référence vers l'objet nouvellement créé.

Cette fonction a été introduite dans Qt 6.6.

[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)

Cette surchargement a pour but de prendre en charge les types dont les constructeurs acceptent une liste d’ initializer_list. Son comportement est par ailleurs équivalent à celui du surchargement sans liste d’initialisation.

Cette fonction a été introduite dans Qt 6.6.

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

Crée une variante de type type et l’initialise avec une copie de *copy si copy n’est pas nullptr (auquel cas, copy doit pointer vers un objet de type type).

Notez que vous devez passer l'adresse de l'objet que vous souhaitez stocker.

En règle générale, vous n’avez jamais besoin d’utiliser ce constructeur ; utilisez plutôt QVariant::fromValue() pour construire des variantes à partir des types de pointeurs représentés par QMetaType::VoidStar et QMetaType::QObjectStar.

Si type ne prend pas en charge la construction par copie et que copy n’est pas nullptr, la variante sera invalide. De même, si copy est nullptr et que type ne prend pas en charge la construction par défaut, la variante sera invalide.

Renvoie l’ QVariant créé comme décrit ci-dessus.

Cette fonction a été introduite dans Qt 6.7.

Voir également QVariant::fromValue() et QMetaType::Type.

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

Renvoie un ` QVariant ` contenant le type et la valeur de la variante active de ` value`. Si le type actif est `std::monostate`, un ` QVariant ` par défaut est renvoyé.

Voir également fromValue().

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

Cette fonction a été introduite dans Qt 6.6.

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

Renvoie un objet ` QVariant ` contenant une copie de ` value`. Pour le reste, son comportement est exactement identique à celui de la fonction ` setValue()`.

Exemple :

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

Voir également setValue() et value().

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

Cette fonction a été introduite dans Qt 6.6.

bool QVariant::isNull() const

Renvoie « true » s'il s'agit d'un variant nul, « false » dans le cas contraire.

Un variant est considéré comme nul s'il ne contient aucune valeur initialisée ou s'il contient un pointeur nul.

Voir aussi convert().

bool QVariant::isValid() const

Renvoie « true » si le type de stockage de cette variante n'est pas « QMetaType::UnknownType » ; sinon, renvoie « false ».

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

Renvoie l'QMetaType e de la valeur stockée dans la variante.

Cette fonction a été introduite dans Qt 6.0.

void QVariant::setValue(QVariant &&value)

Déplace value vers cette adresse QVariant. Cela revient simplement à attribuer value à cette adresse QVariant.

Voir également value().

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

Stocke une copie de value. Si T est d'un type que QVariant ne prend pas en charge, QMetaType est utilisé pour stocker la valeur. Une erreur de compilation se produira si QMetaType ne gère pas ce type.

Exemple :

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>();

Voir également value(), fromValue() et canConvert().

void QVariant::setValue(const QVariant &value)

Copie value sur cette page QVariant. Cela revient simplement à associer value à cette page QVariant.

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

Permet d'échanger cette variante contre celle de other. Cette opération est très rapide et ne pose jamais de problème.

QBitArray QVariant::toBitArray() const

Renvoie la variante sous forme de ` QBitArray ` si celle-ci possède ` userType()` QMetaType::QBitArray; sinon, renvoie un tableau de bits vide.

Voir également canConvert() et convert().

bool QVariant::toBool() const

Renvoie la variante sous forme de valeur booléenne si celle-ci possède la propriété userType().

Renvoie « true » si la variante a pour type « userType() » QMetaType::Bool, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::UInt ou QMetaType::ULongLong et que la valeur est non nulle, ou si la variante a pour type « QMetaType::QString » ou « QMetaType::QByteArray » et que son contenu en minuscules n'est pas l'un des suivants : vide, « 0 » ou « false » ; sinon, renvoie « false ».

Voir également canConvert() et convert().

QByteArray QVariant::toByteArray() const

Renvoie la variante sous la forme d'un « QByteArray » si celle-ci possède les propriétés « userType() » QMetaType::QByteArray ou « QMetaType::QString » (converties à l'aide de « QString::fromUtf8() ») ; sinon, renvoie un tableau d'octets vide.

Voir également canConvert() et convert().

QChar QVariant::toChar() const

Renvoie la variante sous la forme d'un objet de type « QChar » si celle-ci possède l'une des valeurs suivantes : userType() QMetaType::QChar, QMetaType::Int ou QMetaType::UInt; sinon, renvoie un objet « QChar » non valide.

Voir également canConvert() et convert().

QDate QVariant::toDate() const

Renvoie la variante sous forme de ` QDate ` si celle-ci contient l'une des valeurs suivantes : ` userType()`, ` QMetaType::QDate`, ` QMetaType::QDateTime` ou ` QMetaType::QString` ; sinon, renvoie une date non valide.

Si la fonction metaType() est définie sur QMetaType::QString, une date invalide sera renvoyée si la chaîne ne peut pas être analysée comme une date au format Qt::ISODate.

Voir également canConvert() et convert().

QDateTime QVariant::toDateTime() const

Renvoie la variante sous forme de ` QDateTime ` si celle-ci a la valeur ` userType()`, ` QMetaType::QDateTime`, ` QMetaType::QDate` ou ` QMetaType::QString` ; sinon, renvoie une date/heure non valide.

Si l'metaType() est QMetaType::QString, une date/heure non valide sera renvoyée si la chaîne ne peut pas être analysée comme une date/heure au format Qt::ISODate.

Voir également canConvert() et convert().

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

Renvoie la variante sous forme de nombre à virgule flottante double si celle-ci possède l’une des propriétés suivantes : userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt ou QMetaType::ULongLong; sinon, renvoie 0,0.

Si ok est non nul : *ok est défini sur true si la valeur a pu être convertie en double ; sinon *ok est défini sur false.

Voir également canConvert() et convert().

QEasingCurve QVariant::toEasingCurve() const

Renvoie la variante sous la forme d'un objet ` QEasingCurve ` si celle-ci dispose de la méthode ` userType()` QMetaType::QEasingCurve; sinon, renvoie une courbe d'accélération par défaut.

Voir également canConvert() et convert().

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

Renvoie la variante sous forme de nombre à virgule flottante si celle-ci possède l'une des propriétés suivantes : userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt ou QMetaType::ULongLong; sinon, renvoie 0,0.

Si ok est non nul : *ok est défini sur true si la valeur a pu être convertie en double ; sinon *ok est défini sur false.

Voir également canConvert() et convert().

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

Renvoie la variante sous la forme d'un QHash<QString, QVariant> si la variante dispose de metaType() QMetaType::QVariantHash. Si ce n'est pas le cas, QVariant tentera de convertir le type en un hachage, puis le renverra. Cela fonctionnera pour tout type ayant enregistré un convertisseur via QVariantHash ou ayant été déclaré comme conteneur associatif à l'aide de Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE. Si aucune de ces conditions n'est remplie, cette fonction renverra un hachage vide.

Voir également canConvert() et convert().

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

Renvoie la variante sous forme d'entier si celle-ci possède l'une des propriétés suivantes : userType() QMetaType::Int, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt ou QMetaType::ULongLong; sinon, renvoie 0.

Si ok est non nul : *ok est défini sur true si la valeur peut être convertie en int ; sinon *ok est défini sur false.

Avertissement : si la valeur est convertible en « QMetaType::LongLong » mais qu’elle est trop grande pour être représentée dans un entier (« int »), le débordement arithmétique qui en résulte ne sera pas pris en compte par « ok ». Une solution simple consiste à utiliser « QString::toInt() ».

Voir également canConvert() et convert().

QJsonArray QVariant::toJsonArray() const

Renvoie la variante sous la forme d'un ` QJsonArray ` si celle-ci dispose d'une méthode ` userType()` QJsonArray; sinon, renvoie un ` QJsonArray` construit par défaut.

Voir également canConvert() et convert().

QJsonDocument QVariant::toJsonDocument() const

Renvoie la variante sous la forme d'un ` QJsonDocument ` si celle-ci dispose d'un ` userType()` QJsonDocument; sinon, renvoie un ` QJsonDocument` construit par défaut.

Voir également canConvert() et convert().

QJsonObject QVariant::toJsonObject() const

Renvoie la variante sous la forme d'un ` QJsonObject ` si celle-ci dispose d'une méthode ` userType()` QJsonObject; sinon, renvoie un ` QJsonObject` construit par défaut.

Voir également canConvert() et convert().

QJsonValue QVariant::toJsonValue() const

Renvoie la variante sous la forme d'un ` QJsonValue ` si celle-ci dispose d'un ` userType()` QJsonValue; sinon, renvoie un ` QJsonValue` construit par défaut.

Voir également canConvert() et convert().

QLine QVariant::toLine() const

Renvoie la variante sous la forme d'un objet de type « QLine » si celle-ci dispose d'une méthode « userType() » QMetaType::QLine; sinon, renvoie un objet « QLine » non valide.

Voir également canConvert() et convert().

QLineF QVariant::toLineF() const

Renvoie la variante sous la forme d'un objet de type ` QLineF ` si celle-ci possède une méthode ` userType()` QMetaType::QLineF; sinon, renvoie un objet ` QLineF` non valide.

Voir également canConvert() et convert().

QList<QVariant> QVariant::toList() const

Renvoie la variante sous forme de ` QVariantList ` si celle-ci dispose de la méthode ` userType()` QMetaType::QVariantList. Si ce n'est pas le cas, ` QVariant ` tentera de convertir le type en liste, puis le renverra. Cette opération aboutira pour tout type ayant enregistré un convertisseur via ` QVariantList ` ou ayant été déclaré comme conteneur séquentiel à l'aide de ` Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE`. Si aucune de ces conditions n'est remplie, cette fonction renverra une liste vide.

Voir également canConvert() et convert().

QLocale QVariant::toLocale() const

Renvoie la variante sous la forme d'un objet ` QLocale ` si celle-ci dispose de la méthode ` userType()` QMetaType::QLocale; sinon, renvoie un objet invalide ` QLocale`.

Voir également canConvert() et convert().

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

Renvoie la variante sous forme de long long int si celle-ci possède l'une des valeurs suivantes : userType() QMetaType::LongLong, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::QString, QMetaType::UInt ou QMetaType::ULongLong; sinon, renvoie 0.

Si ok est non nul : *ok est défini sur true si la valeur a pu être convertie en int ; sinon, *ok est défini sur false.

Voir également canConvert() et convert().

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

Renvoie la variante sous forme de ` QVariantMap ` si celle-ci dispose de la méthode ` metaType()` QMetaType::QVariantMap. Si ce n'est pas le cas, ` QVariant ` tentera de convertir le type en `map`, puis le renverra. Cette opération réussira pour tout type ayant enregistré un convertisseur via ` QVariantMap ` ou ayant été déclaré comme conteneur associatif à l'aide de ` Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE`. Si aucune de ces conditions n'est remplie, cette fonction renverra une `map` vide.

Voir également canConvert() et convert().

QModelIndex QVariant::toModelIndex() const

Renvoie la variante sous la forme d'un ` QModelIndex ` si celle-ci dispose d'une méthode ` userType()` QModelIndex; sinon, renvoie un ` QModelIndex` construit par défaut.

Voir également canConvert(), convert() et toPersistentModelIndex().

QPersistentModelIndex QVariant::toPersistentModelIndex() const

Renvoie la variante sous la forme d'un objet ` QPersistentModelIndex ` si celle-ci dispose d'une méthode ` userType()` QPersistentModelIndex; sinon, renvoie un objet ` QPersistentModelIndex` construit par défaut.

Voir également canConvert(), convert() et toModelIndex().

QPoint QVariant::toPoint() const

Renvoie la variante sous la forme d'un objet de type ` QPoint ` si celle-ci possède l'une des propriétés suivantes : ` userType()`, ` QMetaType::QPoint ` ou ` QMetaType::QPointF` ; sinon, renvoie un objet null de type ` QPoint`.

Voir également canConvert() et convert().

QPointF QVariant::toPointF() const

Renvoie la variante sous la forme d'un objet de type ` QPointF ` si celle-ci possède un ` userType()`, ` QMetaType::QPoint ` ou ` QMetaType::QPointF` ; sinon, renvoie un ` QPointF` nul.

Voir également canConvert() et convert().

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

Renvoie la variante sous forme de qreal si celle-ci présente l’une des valeurs suivantes : userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt ou QMetaType::ULongLong; sinon, renvoie 0,0.

Si ok est non nul : *ok est défini sur true si la valeur a pu être convertie en double ; sinon *ok est défini sur false.

Voir également canConvert() et convert().

QRect QVariant::toRect() const

Renvoie la variante sous forme de ` QRect ` si celle-ci dispose d'un ` userType()` QMetaType::QRect; sinon, renvoie une valeur non valide de type ` QRect`.

Voir également canConvert() et convert().

QRectF QVariant::toRectF() const

Renvoie la variante sous la forme d'un ` QRectF ` si celle-ci possède l'une des propriétés suivantes : ` userType()`, ` QMetaType::QRect ` ou ` QMetaType::QRectF` ; sinon, renvoie un ` QRectF` non valide.

Voir également canConvert() et convert().

QRegularExpression QVariant::toRegularExpression() const

Renvoie la variante sous la forme d'un objet de type « QRegularExpression » si celle-ci dispose d'une méthode « userType() » QRegularExpression; sinon, renvoie un objet vide de type « QRegularExpression ».

Voir également canConvert() et convert().

QSize QVariant::toSize() const

Renvoie la variante sous la forme d'un objet « QSize » si celle-ci dispose de la méthode « userType() » QMetaType::QSize; sinon, renvoie un objet « QSize » non valide.

Voir également canConvert() et convert().

QSizeF QVariant::toSizeF() const

Renvoie la variante sous la forme d'un objet de type « QSizeF » si celle-ci dispose d'une méthode « userType() » QMetaType::QSizeF; sinon, renvoie un objet « QSizeF » non valide.

Voir également canConvert() et convert().

QString QVariant::toString() const

Renvoie la variante sous forme de ` QString ` si celle-ci dispose d'un ` userType()` comprenant, entre autres :

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

L'appel de la méthode QVariant::toString() sur un variant non pris en charge renvoie une chaîne vide.

Voir également canConvert() et convert().

QStringList QVariant::toStringList() const

Renvoie la variante sous forme de ` QStringList ` si celle-ci possède un ` userType()` QMetaType::QStringList, ` QMetaType::QString` ou ` QMetaType::QVariantList ` d'un type pouvant être converti en ` QString` ; sinon, renvoie une liste vide.

Voir également canConvert() et convert().

QTime QVariant::toTime() const

Renvoie la variante sous forme de ` QTime ` si celle-ci a la valeur ` userType()`, ` QMetaType::QTime`, ` QMetaType::QDateTime` ou ` QMetaType::QString` ; sinon, renvoie une heure non valide.

Si la fonction metaType() est définie sur QMetaType::QString, une heure non valide sera renvoyée si la chaîne ne peut pas être analysée comme une heure au format Qt::ISODate.

Voir également canConvert() et convert().

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

Renvoie la variante sous la forme d'un entier non signé si celle-ci possède l'une des propriétés suivantes : userType() QMetaType::UInt, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString ou QMetaType::ULongLong; sinon, renvoie 0.

Si ok est non nul : *ok est défini sur true si la valeur peut être convertie en unsigned int ; sinon *ok est défini sur false.

Avertissement : si la valeur est convertible en « QMetaType::ULongLong » mais qu’elle est trop grande pour être représentée dans un « unsigned int », le débordement arithmétique qui en résulte ne sera pas pris en compte par « ok ». Une solution simple consiste à utiliser « QString::toUInt() ».

Voir également ` canConvert()` et ` convert()`.

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

Renvoie la variante sous la forme d'un entier long long non signé si la variante possède l'une des propriétés suivantes : metaType() QMetaType::ULongLong, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString ou QMetaType::UInt; sinon, renvoie 0.

Si ok est non nul : *ok est défini sur true si la valeur a pu être convertie en int ; sinon, *ok est défini sur false.

Voir également canConvert() et convert().

QUrl QVariant::toUrl() const

Renvoie la variante sous la forme d'un objet de type « QUrl » si celle-ci possède une propriété « userType() » QMetaType::QUrl; sinon, renvoie un objet « QUrl » non valide.

Voir également canConvert() et convert().

QUuid QVariant::toUuid() const

Renvoie la variante sous la forme d’un ` QUuid ` si celle-ci possède l’une des propriétés suivantes : ` metaType()`, ` QMetaType::QUuid`, ` QMetaType::QByteArray ` ou ` QMetaType::QString` ; sinon, renvoie un ` QUuid` construit par défaut.

Voir également canConvert() et convert().

Renvoie le type de stockage de la valeur stockée dans la variante. Cela revient à appeler la fonction metaType().id().

Voir aussi metaType().

const char *QVariant::typeName() const

Renvoie le nom du type stocké dans la variante. Les chaînes renvoyées décrivent le type de données C++ utilisé pour stocker les données : par exemple, «QFont », «QString » ou «QVariantList ». Une variante non valide renvoie 0.

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

Renvoie la valeur stockée convertie au type du modèle T. Appelez la fonction canConvert() pour savoir si un type peut être converti. Si la valeur ne peut pas être convertie, une valeur construite par défaut sera renvoyée.

Si le type T est pris en charge par QVariant, cette fonction se comporte exactement comme toString(), toInt() etc.

Exemple :

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

Si la variable QVariant contient un pointeur vers un type dérivé de QObject, alors T peut être de n’importe quel type QObject. Si le pointeur stocké dans la variable QVariant peut être converti ( qobject_cast ) en T, alors ce résultat est renvoyé. Sinon, nullptr est renvoyé. Notez que cela ne fonctionne que pour les sous-classes de QObject qui utilisent la macro Q_OBJECT.

Si l’ QVariant contient un conteneur séquentiel et que T vaut QVariantList, les éléments du conteneur seront convertis en QVariants et renvoyés sous la forme d’un QVariantList.

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

QVariant variant = QVariant::fromValue(intList);
if (variant.canConvert<QVariantList>()) {
    QMetaSequence::Iterable iterable = variant.value<QMetaSequence::Iterable>();
    // Possibilité d'utiliser la boucle « range-for » de C++11 :
    for (const QVariant&v: iterable) {
        qDebug() << v;
    }
    // Possibilité d'utiliser des itérateurs :
    QMetaSequence::Iterable::const_iteratorit = iterable.begin();
    const QMetaSequence::Iterable::const_iteratorend = iterable.end();
    for ( ; it != end;++it) {
        qDebug() << *it;
    }
}

Voir également setValue(), fromValue(), canConvert() et Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE().

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

Renvoie une vue modifiable de type modèle « T » sur la valeur stockée. Appelez canView() pour savoir si une telle vue est prise en charge. Si aucune vue de ce type ne peut être créée, renvoie la valeur stockée convertie au type de modèle T. Appelez canConvert() pour savoir si un type peut être converti. Si la valeur ne peut être ni visualisée ni convertie, une valeur construite par défaut sera renvoyée.

Voir également canView() et Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE().

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

Cette opération attribue l'other à cette instance QVariant.

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

Attribue la valeur de la variante « variant » à cette variante.