QVariant Class

Documentation sur les fonctions membres

[noexcept] QVariant::QVariant()

Construit une variante non valide.

[noexcept] QVariant::QVariant(QChar c)

Construit une nouvelle variante avec une valeur char, c.

QVariant::QVariant(const char *val)

Construit une nouvelle variante avec une valeur de chaîne de val. La variante crée une copie profonde de val dans un QString en supposant un encodage UTF-8 sur l'entrée val.

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)

Construit une nouvelle variante avec une valeur en virgule flottante, val.

[noexcept] QVariant::QVariant(float val)

Construit une nouvelle variante avec une valeur en virgule flottante, val.

[noexcept] QVariant::QVariant(int val)

Construit une nouvelle variante avec une valeur entière, val.

[noexcept] QVariant::QVariant(qlonglong val)

Construit une nouvelle variante avec une valeur entière longue, val.

[noexcept] QVariant::QVariant(qulonglong val)

Construit une nouvelle variante avec une valeur entière longue non signée, val.

[noexcept] QVariant::QVariant(uint val)

Construit une nouvelle variante avec une valeur entière non signée, val.

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

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

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

En général, 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 de copies et que copy n'est pas nullptr, la variante sera invalide. De même, si copy est nullptr et que type ne supporte pas la construction par défaut, la variante sera invalide.

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

[explicit noexcept(...), since 6.6] template < typename T, typename... Args, QVariant::if_constructible<T, Args...> = true > 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 pour la compatibilité STL/std::any.

Contraintes

Participe à la résolution de surcharge uniquement 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, QVariant::if_constructible<T, std::initializer_list<U> &, Args...> = true > QVariant::QVariant(std::in_place_type_t<T>, std::initializer_list<U> il, Args &&... args)

Cette surcharge existe pour prendre en charge les types dont les constructeurs prennent un initializer_list. Son comportement est par ailleurs équivalent à celui de la surcharge de la liste non initialisante in_place_type_t.

Cette fonction a été introduite dans Qt 6.6.

[noexcept] QVariant::QVariant(QDate val)

Construit une nouvelle variante avec une valeur de date, val.

QVariant::QVariant(QLatin1StringView val)

Construit une nouvelle variante avec une valeur QString à partir de la chaîne Latin-1 vue par val.

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

Construit une nouvelle variante avec une valeur de ligne de val.

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

Construit une nouvelle variante avec une valeur de ligne de val.

[noexcept] QVariant::QVariant(QPoint val)

Construit une nouvelle variante avec une valeur de point de val.

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

Construit une nouvelle variante avec une valeur de point de val.

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

Construit une nouvelle variante avec une valeur rect de val.

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

Construit une nouvelle variante avec une valeur rect de val.

[noexcept] QVariant::QVariant(QSize val)

Construit une nouvelle variante avec une valeur de taille de val.

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

Construit une nouvelle variante avec une valeur de taille de val.

[noexcept] QVariant::QVariant(QTime val)

Construit une nouvelle variante avec une valeur temporelle, val.

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

Construit une nouvelle variante avec une valeur uuid, val.

[noexcept] QVariant::QVariant(bool val)

Construit une nouvelle variante avec une valeur booléenne, val.

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

Construit une nouvelle variante avec une valeur bitarray, val.

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

Construit une nouvelle variante avec une valeur de tableau d'octets, val.

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

Construit une nouvelle variante avec une valeur de date/heure, val.

QVariant::QVariant(const QEasingCurve &val)

Construit une nouvelle variante avec une valeur de courbe d'assouplissement, val.

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

Construit une nouvelle variante avec un hachage de QVariants, val.

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

Construit une nouvelle variante avec un tableau de valeurs json, val.

QVariant::QVariant(const QJsonDocument &val)

Construit une nouvelle variante avec une valeur de document json, val.

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

Construit une nouvelle variante avec une valeur d'objet json, val.

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

Construit une nouvelle variante avec une valeur json, val.

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

Construit une nouvelle variante avec une valeur de liste, val.

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

Construit une nouvelle variante avec une valeur locale, l.

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

Construit une nouvelle variante avec une carte de QVariants, val.

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

Construit une nouvelle variante avec une valeur QModelIndex, val.

QVariant::QVariant(const QPersistentModelIndex &val)

Construit une nouvelle variante avec une valeur QPersistentModelIndex, val.

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

Construit une nouvelle variante avec la valeur de l'expression régulière re.

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

Construit une nouvelle variante avec une valeur de chaîne, val.

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

Construit une nouvelle variante avec une valeur de liste de chaînes, val.

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

Construit une nouvelle variante avec une valeur d'url de val.

QVariant::QVariant(const QVariant &p)

Construit une copie de la variante, p, transmise en tant qu'argument à ce constructeur.

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

Move-construit une instance de QVariant, en la faisant pointer sur le même objet que other.

[noexcept] QVariant::~QVariant()

Détruit le site QVariant et l'objet qu'il contient.

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

Renvoie true si la variante peut être convertie dans le 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 vrai pour cette fonction si un qobject_cast vers le type modèle T réussirait. Notez que cela ne fonctionne que pour les sous-classes QObject qui utilisent la macro Q_OBJECT.

Voir aussi convert().

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

Renvoie true si le type de la variante peut être converti dans le type demandé, type. Cette conversion est effectuée automatiquement lors de l'appel aux méthodes toInt(), toBool(), ....

Notez que cette fonction n'opère que sur le type de la variante, pas sur son contenu. Elle indique s'il existe un chemin de conversion de cette variante vers type, et non pas si la conversion réussira lorsqu'elle sera tentée.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi QMetaType::canConvert().

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

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

Voir aussi value().

void QVariant::clear()

Convertir cette variante au type QMetaType::UnknownType et libérer les ressources utilisées.

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

Compare les objets à lhs et rhs pour l'ordre.

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

Si les variantes contiennent des données d'un métatype différent, 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 de comparaison numérique ou pointeur habituelles seront utilisées.

Si les deux variantes contiennent des données du même métatype, la méthode utilisera la méthode QMetaType::compare pour déterminer l'ordre des deux variantes, ce qui peut également indiquer qu'elle ne peut pas établir d'ordre entre les deux valeurs.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi QMetaType::compare() et QMetaType::isOrdered().

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

Voir aussi get_if() et QMetaType.

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

Transforme la variante en type demandé, targetType. Si la conversion ne peut être effectuée, la variante est tout de même transformée en type demandé, mais elle est laissée dans un état nul, similaire à celui construit par QVariant(Type).

Renvoie true si le type actuel de la variante a été converti avec succès ; sinon, renvoie false.

Un QVariant contenant un pointeur vers un type dérivé de QObject sera également converti et renverra vrai pour cette fonction si un qobject_cast vers le type décrit par targetType réussirait. 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 aussi canConvert() et clear().

void *QVariant::data()

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

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

Voir aussi get_if() et QMetaType.

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

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

Cette fonction a été introduite dans Qt 6.6.

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

Cette surcharge existe pour prendre en charge les types dont les constructeurs prennent un initializer_list. Elle se comporte de manière équivalente à la surcharge de la liste non initialisante.

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 (dans ce cas, copy doit pointer vers un objet de type type).

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

En général, 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 de copies et que copy n'est pas nullptr, la variante sera invalide. De même, si copy est nullptr et que type ne supporte pas la construction par défaut, la variante sera invalide.

Renvoie l'adresse QVariant créée comme décrit ci-dessus.

Cette fonction a été introduite dans Qt 6.7.

Voir aussi QVariant::fromValue() et QMetaType::Type.

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

Renvoie un QVariant avec 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 aussi 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 QVariant contenant une copie de value. Sinon, il se comporte exactement comme setValue().

Exemple :

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

Voir aussi setValue() et value().

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

Cette fonction a été introduite dans Qt 6.6.

bool QVariant::isNull() const

Retourne true s'il s'agit d'une variante nulle, false sinon.

Une variante est considérée comme nulle si elle ne contient aucune valeur initialisée ou 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'adresse QMetaType 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 sur QVariant. Il est équivalent à un simple déplacement assignant value à ce QVariant.

Voir aussi 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 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 le 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 QVariant. Cela équivaut à assigner simplement value à ce QVariant.

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

Remplace cette variante par other. Cette opération est très rapide et n'échoue jamais.

QBitArray QVariant::toBitArray() const

Renvoie la variante sous forme de QBitArray si la variante a userType() QMetaType::QBitArray; sinon, renvoie un tableau de bits vide.

Voir aussi canConvert() et convert().

bool QVariant::toBool() const

Renvoie la variante sous forme de bool si la variante est de type userType() Bool.

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

Voir également canConvert() et convert().

QByteArray QVariant::toByteArray() const

Renvoie la variante sous forme de QByteArray si la variante a userType() QMetaType::QByteArray ou QMetaType::QString (converti en utilisant QString::fromUtf8()) ; sinon, renvoie un tableau d'octets vide.

Voir aussi canConvert() et convert().

QChar QVariant::toChar() const

Renvoie la variante sous forme de QChar si la variante a userType() QMetaType::QChar, QMetaType::Int, ou QMetaType::UInt; sinon renvoie une QChar invalide.

Voir aussi canConvert() et convert().

QDate QVariant::toDate() const

Renvoie la variante sous forme de QDate si la variante possède userType() QMetaType::QDate, QMetaType::QDateTime, ou QMetaType::QString; sinon, renvoie une date invalide.

Si metaType() est 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 aussi canConvert() et convert().

QDateTime QVariant::toDateTime() const

Renvoie la variante sous forme de QDateTime si la variante contient userType() QMetaType::QDateTime, QMetaType::QDate, ou QMetaType::QString; sinon, renvoie une date/heure invalide.

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

Voir aussi canConvert() et convert().

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

Renvoie la variante sous la forme d'un double si la variante possède 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 mis à vrai si la valeur a pu être convertie en double ; sinon *ok est mis à faux.

Voir aussi canConvert() et convert().

QEasingCurve QVariant::toEasingCurve() const

Renvoie la variante sous forme de QEasingCurve si la variante a userType() QMetaType::QEasingCurve; sinon, renvoie une courbe d'assouplissement par défaut.

Voir aussi canConvert() et convert().

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

Renvoie la variante sous la forme d'un flottant si la variante a 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 mis à vrai si la valeur a pu être convertie en double ; sinon *ok est mis à faux.

Voir aussi canConvert() et convert().

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

Renvoie la variante sous forme de QHash<QString, QVariant> si la variante a metaType() QMetaType::QVariantHash. Si ce n'est pas le cas, QVariant tentera de convertir le type en un hachage et de le renvoyer. Cela réussira pour tout type qui a enregistré un convertisseur vers QVariantHash ou qui a été déclaré comme un conteneur associatif en utilisant Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE. Si aucune de ces conditions n'est remplie, cette fonction renverra un hachage vide.

Voir aussi canConvert() et convert().

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

Renvoie la variante sous la forme d'un int si la variante possède 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 mis à vrai si la valeur peut être convertie en un int ; sinon *ok est mis à faux.

Attention : Si la valeur est convertible en QMetaType::LongLong mais est trop grande pour être représentée par un int, le dépassement arithmétique qui en résulte ne sera pas reflété dans ok. Une solution simple consiste à utiliser QString::toInt().

Voir aussi canConvert() et convert().

QJsonArray QVariant::toJsonArray() const

Renvoie la variante sous forme de QJsonArray si la variante a userType() QJsonArray; sinon, renvoie un QJsonArray construit par défaut.

Voir aussi canConvert() et convert().

QJsonDocument QVariant::toJsonDocument() const

Renvoie la variante sous forme de QJsonDocument si la variante a userType() QJsonDocument; sinon, renvoie un QJsonDocument construit par défaut.

Voir aussi canConvert() et convert().

QJsonObject QVariant::toJsonObject() const

Renvoie la variante sous forme de QJsonObject si la variante a userType() QJsonObject; sinon, renvoie un QJsonObject construit par défaut.

Voir aussi canConvert() et convert().

QJsonValue QVariant::toJsonValue() const

Renvoie la variante sous forme de QJsonValue si la variante a userType() QJsonValue; sinon, renvoie un QJsonValue construit par défaut.

Voir aussi canConvert() et convert().

QLine QVariant::toLine() const

Renvoie la variante sous forme de QLine si la variante a userType() QMetaType::QLine; sinon, renvoie une QLine invalide.

Voir aussi canConvert() et convert().

QLineF QVariant::toLineF() const

Renvoie la variante sous forme de QLineF si la variante a userType() QMetaType::QLineF; sinon, renvoie une QLineF invalide.

Voir aussi canConvert() et convert().

QList<QVariant> QVariant::toList() const

Renvoie la variante sous forme de QVariantList si la variante a userType() QMetaType::QVariantList. Si ce n'est pas le cas, QVariant tentera de convertir le type en liste et de le renvoyer. Cela réussira pour tout type qui a enregistré un convertisseur à QVariantList ou qui a été déclaré comme un 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 aussi canConvert() et convert().

QLocale QVariant::toLocale() const

Renvoie la variante sous forme de QLocale si la variante a userType() QMetaType::QLocale; sinon, renvoie une QLocale invalide.

Voir aussi canConvert() et convert().

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

Renvoie la variante sous la forme d'un long long int si la variante possède 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 mis à vrai si la valeur a pu être convertie en un int ; sinon *ok est mis à faux.

Voir aussi canConvert() et convert().

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

Renvoie la variante sous forme de QVariantMap si la variante a metaType() QMetaType::QVariantMap. Si ce n'est pas le cas, QVariant tentera de convertir le type en une carte et de la renvoyer. Cela réussira pour tout type qui a enregistré un convertisseur vers QVariantMap ou qui a été déclaré comme un conteneur associatif en utilisant Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE. Si aucune de ces conditions n'est remplie, cette fonction renverra une carte vide.

Voir aussi canConvert() et convert().

QModelIndex QVariant::toModelIndex() const

Renvoie la variante sous forme de QModelIndex si la variante a userType() QModelIndex; sinon, renvoie un QModelIndex construit par défaut.

Voir aussi canConvert(), convert(), et toPersistentModelIndex().

QPersistentModelIndex QVariant::toPersistentModelIndex() const

Renvoie la variante sous forme de QPersistentModelIndex si la variante a userType() QPersistentModelIndex; sinon, renvoie un QPersistentModelIndex construit par défaut.

Voir aussi canConvert(), convert(), et toModelIndex().

QPoint QVariant::toPoint() const

Renvoie la variante sous forme de QPoint si la variante a userType() QMetaType::QPoint ou QMetaType::QPointF; sinon, renvoie une QPoint nulle.

Voir aussi canConvert() et convert().

QPointF QVariant::toPointF() const

Renvoie la variante sous forme de QPointF si la variante a userType() QMetaType::QPoint ou QMetaType::QPointF; sinon, renvoie une QPointF nulle.

Voir aussi canConvert() et convert().

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

Renvoie la variante sous forme de qreal si la variante possède 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 mis à vrai si la valeur a pu être convertie en double ; sinon *ok est mis à faux.

Voir aussi canConvert() et convert().

QRect QVariant::toRect() const

Renvoie la variante sous forme de QRect si la variante a userType() QMetaType::QRect; sinon, renvoie une QRect invalide.

Voir aussi canConvert() et convert().

QRectF QVariant::toRectF() const

Renvoie la variante sous forme de QRectF si la variante a userType() QMetaType::QRect ou QMetaType::QRectF; sinon, renvoie une QRectF invalide.

Voir aussi canConvert() et convert().

QRegularExpression QVariant::toRegularExpression() const

Renvoie la variante sous forme de QRegularExpression si la variante a userType() QRegularExpression; sinon, renvoie une QRegularExpression vide.

Voir aussi canConvert() et convert().

QSize QVariant::toSize() const

Renvoie la variante sous forme de QSize si la variante a userType() QMetaType::QSize; sinon, renvoie une QSize invalide.

Voir aussi canConvert() et convert().

QSizeF QVariant::toSizeF() const

Renvoie la variante sous forme de QSizeF si la variante a userType() QMetaType::QSizeF; sinon, renvoie une QSizeF invalide.

Voir aussi canConvert() et convert().

QString QVariant::toString() const

Retourne la variante sous forme de QString si la variante a un userType() incluant, mais non limité à :

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 à QVariant::toString() sur une variante non prise en charge renvoie une chaîne vide.

Voir aussi canConvert() et convert().

QStringList QVariant::toStringList() const

Renvoie la variante sous forme de QStringList si la variante a userType() QMetaType::QStringList, QMetaType::QString, ou QMetaType::QVariantList d'un type qui peut être converti en QString; sinon, renvoie une liste vide.

Voir aussi canConvert() et convert().

QTime QVariant::toTime() const

Renvoie la variante sous forme de QTime si la variante possède userType() QMetaType::QTime, QMetaType::QDateTime, ou QMetaType::QString; sinon, renvoie une heure invalide.

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

Voir aussi canConvert() et convert().

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

Renvoie la variante sous la forme d'un int non signé si la variante possède 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 mis à vrai si la valeur peut être convertie en un int non signé ; sinon *ok est mis à faux.

Attention : Si la valeur est convertible en QMetaType::ULongLong mais qu'elle est trop grande pour être représentée dans un int non signé, le dépassement arithmétique qui en résulte ne sera pas reflété dans ok. Une solution simple consiste à utiliser QString::toUInt().

Voir aussi canConvert() et convert().

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

Renvoie la variante sous la forme d'un long long int non signé si la variante a pour nom 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 mis à vrai si la valeur a pu être convertie en un int ; sinon *ok est mis à faux.

Voir aussi canConvert() et convert().

QUrl QVariant::toUrl() const

Renvoie la variante sous forme de QUrl si la variante a userType() QMetaType::QUrl; sinon, renvoie une QUrl invalide.

Voir aussi canConvert() et convert().

QUuid QVariant::toUuid() const

Renvoie la variante sous forme de QUuid si la variante possède metaType() QMetaType::QUuid, QMetaType::QByteArray ou QMetaType::QString; sinon, renvoie une QUuid construite par défaut.

Voir aussi canConvert() et convert().

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.

Renvoie le type de stockage de la valeur stockée dans la variante. C'est la même chose que metaType().id().

Voir aussi metaType().

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

Renvoie la valeur stockée convertie dans le type de modèle T. Appelez 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 QVariant contient un pointeur sur un type dérivé de QObject, alors T peut être n'importe quel type QObject. Si le pointeur stocké dans QVariant peut être qobject_cast vers T, ce résultat est renvoyé. Sinon, nullptr est renvoyé. Notez que cela ne fonctionne que pour les sous-classes QObject qui utilisent la macro Q_OBJECT.

Si QVariant contient un conteneur séquentiel et que T est QVariantList, les éléments du conteneur seront convertis en QVariantet renvoyés sous forme de QVariantList.

QList<int> intList = {7, 11, 42};QVariant variante = QVariant::fromValue(intList) ;if (variant.canConvert<QVariantList>()) { QMetaSequence::Iterable iterable = variant.value<QMetaSequence::Iterable>() ; // Peut utiliser C++11 range-for : for(const QVariant &v: iterable) {        qDebug() << v;
    } // On peut utiliser des itérateurs: QMetaSequence::Iterable::const_iterator it = iterable.begin() ; const QMetaSequence::Iterable::const_iterator end = iterable.end() ; for ( ; it != end ; ++it) {        qDebug() << *it;
    } }

Voir aussi setValue(), fromValue(), canConvert(), et Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE().

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

Renvoie une vue mutable de type 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)

Move-assigne other à cette instance QVariant.

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

Attribue la valeur de la variante variant à cette variante.