QSharedPointer Class
template <typename T> class QSharedPointerLa classe QSharedPointer contient une référence forte vers un pointeur partagé. En savoir plus...
| En-tête : | #include <QSharedPointer> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake : | QT += core |
Remarque : toutes les fonctions de cette classe sont réentrantes.
Comparaisons avec QSharedPointer
| Catégorie | Types comparables | Description |
|---|---|---|
| strong | QSharedPointer | |
| strong | QSharedPointer<X>, X* et std::nullptr_t. | Où X et T sont des types compatibles, ce qui signifie qu’ils sont soit identiques, soit que l’un est un type de base de l’autre. |
Fonctions publiques
| QSharedPointer() | |
| QSharedPointer(QSharedPointer<X> &&other) | |
| QSharedPointer(X *ptr) | |
| QSharedPointer(const QWeakPointer<T> &other) | |
| QSharedPointer(std::nullptr_t) | |
| QSharedPointer(X *ptr, Deleter d) | |
| QSharedPointer(std::nullptr_t, Deleter d) | |
| QSharedPointer(const QSharedPointer<T> &other) | |
| QSharedPointer(QSharedPointer<T> &&other) | |
| ~QSharedPointer() | |
| void | clear() |
| QSharedPointer<X> | constCast() const & |
(since 6.9) QSharedPointer<X> | constCast() && |
| T * | data() const |
| QSharedPointer<X> | dynamicCast() const & |
(since 6.9) QSharedPointer<X> | dynamicCast() && |
| T * | get() const |
| bool | isNull() const |
| QSharedPointer<X> | objectCast() const & |
(since 6.9) QSharedPointer<X> | objectCast() && |
(since 6.7) bool | owner_before(const QSharedPointer<X> &other) const |
(since 6.7) bool | owner_before(const QWeakPointer<X> &other) const |
(since 6.7) bool | owner_equal(const QSharedPointer<X> &other) const |
(since 6.7) bool | owner_equal(const QWeakPointer<X> &other) const |
(since 6.7) size_t | owner_hash() const |
| void | reset() |
| void | reset(T *t) |
| void | reset(T *t, Deleter deleter) |
| QSharedPointer<X> | staticCast() const & |
(since 6.9) QSharedPointer<X> | staticCast() && |
| void | swap(QSharedPointer<T> &other) |
| QWeakPointer<T> | toWeakRef() const |
| operator bool() const | |
| bool | operator!() const |
| T & | operator*() const |
| T * | operator->() const |
| QSharedPointer<T> & | operator=(QSharedPointer<T> &&other) |
| QSharedPointer<T> & | operator=(QSharedPointer<X> &&other) |
| QSharedPointer<T> & | operator=(const QSharedPointer<T> &other) |
| QSharedPointer<T> & | operator=(const QWeakPointer<T> &other) |
Membres publics statiques
| QSharedPointer<T> | create(Args &&... args) |
Éléments non membres associés
| size_t | qHash(const QSharedPointer<T> &key, size_t seed = 0) |
| QSharedPointer<X> | qSharedPointerCast(const QSharedPointer<T> &other) |
| QSharedPointer<X> | qSharedPointerCast(const QWeakPointer<T> &other) |
(since 6.9) QSharedPointer<X> | qSharedPointerCast(QSharedPointer<T> &&other) |
| QSharedPointer<X> | qSharedPointerConstCast(const QSharedPointer<T> &src) |
| QSharedPointer<X> | qSharedPointerConstCast(const QWeakPointer<T> &src) |
(since 6.9) QSharedPointer<X> | qSharedPointerConstCast(QSharedPointer<T> &&src) |
| QSharedPointer<X> | qSharedPointerDynamicCast(const QSharedPointer<T> &src) |
| QSharedPointer<X> | qSharedPointerDynamicCast(const QWeakPointer<T> &src) |
(since 6.9) QSharedPointer<X> | qSharedPointerDynamicCast(QSharedPointer<T> &&src) |
| QSharedPointer<X> | qSharedPointerObjectCast(const QSharedPointer<T> &src) |
| QSharedPointer<X> | qSharedPointerObjectCast(const QWeakPointer<T> &src) |
| std::shared_ptr<X> | qSharedPointerObjectCast(const std::shared_ptr<T> &src) |
| std::shared_ptr<X> | qSharedPointerObjectCast(std::shared_ptr<T> &&src) |
(since 6.9) QSharedPointer<X> | qSharedPointerObjectCast(QSharedPointer<T> &&src) |
(since 6.12) QSharedPointer<X> | qSharedPointerStaticCast(const QSharedPointer<T> &other) |
(since 6.12) QSharedPointer<X> | qSharedPointerStaticCast(const QWeakPointer<T> &other) |
(since 6.12) QSharedPointer<X> | qSharedPointerStaticCast(QSharedPointer<T> &&other) |
| std::shared_ptr<X> | qobject_pointer_cast(const std::shared_ptr<T> &src) |
| std::shared_ptr<X> | qobject_pointer_cast(std::shared_ptr<T> &&src) |
| bool | operator!=(const QSharedPointer<T> &lhs, const QSharedPointer<X> &rhs) |
| bool | operator!=(const QSharedPointer<T> &lhs, const X *rhs) |
| bool | operator!=(const QSharedPointer<T> &lhs, std::nullptr_t) |
| bool | operator!=(const T *lhs, const QSharedPointer<X> &rhs) |
| bool | operator!=(std::nullptr_t, const QSharedPointer<T> &rhs) |
| QDebug | operator<<(QDebug debug, const QSharedPointer<T> &ptr) |
| bool | operator==(const QSharedPointer<T> &lhs, const QSharedPointer<X> &rhs) |
| bool | operator==(const QSharedPointer<T> &lhs, const X *rhs) |
| bool | operator==(const QSharedPointer<T> &lhs, std::nullptr_t) |
| bool | operator==(const T *lhs, const QSharedPointer<X> &rhs) |
| bool | operator==(std::nullptr_t, const QSharedPointer<T> &rhs) |
Description détaillée
Le QSharedPointer est un pointeur partagé automatique en C++, où le paramètre de modèle T spécifie le type du pointeur géré. Il se comporte exactement comme un pointeur normal dans le cadre d’une utilisation classique, y compris en ce qui concerne la propriété const.
QSharedPointer supprimera le pointeur qu’il détient lorsqu’il sortira de sa portée, à condition qu’aucun autre objet QSharedPointer ne le référence.
Un objet `QSharedPointer` peut être créé à partir d’un pointeur classique, d’un autre objet `QSharedPointer` ou en transformant un objet de type ` QWeakPointer ` en référence forte.
Sécurité inter-thread
QSharedPointer et QWeakPointer sont des classes réentrantes. Cela signifie qu’en général, un objet QSharedPointer ou QWeakPointer donné ne peut pas être accédé simultanément par plusieurs threads sans synchronisation.
Différents objets `QSharedPointer` et ` QWeakPointer ` peuvent être consultés en toute sécurité par plusieurs threads simultanément. Cela inclut le cas où ils contiennent des pointeurs vers le même objet ; le mécanisme de comptage des références est atomique et aucune synchronisation manuelle n’est requise.
Il convient de noter que, bien que la valeur du pointeur soit accessible de cette manière (c’est-à-dire par plusieurs threads simultanément, sans synchronisation), les classes QSharedPointer et QWeakPointer n’offrent aucune garantie concernant l’objet pointé. Les règles spécifiques de sécurité des threads et de réentrance applicables à cet objet restent en vigueur.
Autres classes de pointeurs
Qt fournit également deux autres classes de wrapper de pointeur : ` QPointer ` et ` QSharedDataPointer`. Elles sont incompatibles entre elles, car chacune a un cas d’utilisation très différent.
QSharedPointer contient un pointeur partagé au moyen d’un compteur de références externe (c’est-à-dire un compteur de références placé en dehors de l’objet). Comme son nom l’indique, la valeur du pointeur est partagée entre toutes les instances de QSharedPointer et d’ QWeakPointer. Le contenu de l’objet pointé par le pointeur ne doit toutefois pas être considéré comme partagé : il n’y a qu’un seul objet. C’est pourquoi QSharedPointer ne permet pas de détacher ou de copier l’objet pointé.
QSharedDataPointer, en revanche, contient un pointeur vers des données partagées (c'est-à-dire une classe dérivée de ` QSharedData`). Il le fait au moyen d’un compteur de références interne, placé dans la classe de base ` QSharedData `. Cette classe peut donc se détacher en fonction du type d’accès effectué sur les données protégées : s’il s’agit d’un accès non-const, elle crée une copie de manière atomique pour que l’opération puisse s’achever.
QExplicitlySharedDataPointer est une variante de ` QSharedDataPointer`, à la différence qu’elle ne se détache que si ` QExplicitlySharedDataPointer::detach()` est explicitement appelée (d’où son nom).
QScopedPointer contient simplement un pointeur vers un objet alloué sur le tas et le supprime dans son destructeur. Cette classe est utile lorsqu’un objet doit être alloué sur le tas puis supprimé, sans autre. ` QScopedPointer ` est légère, elle n’utilise aucune structure supplémentaire ni aucun comptage de références.
Enfin, ` QPointer ` contient un pointeur vers un objet dérivé de ` QObject`, mais de manière faible. ` QWeakPointer ` offre la même fonctionnalité, mais son utilisation à cette fin est dépréciée.
Suivi optionnel des pointeurs
Une fonctionnalité de QSharedPointer pouvant être activée à la compilation à des fins de débogage est un mécanisme de suivi des pointeurs. Lorsqu’elle est activée, QSharedPointer enregistre dans un ensemble global tous les pointeurs qu’il suit. Cela permet de détecter des erreurs telles que l’affectation d’un même pointeur à deux objets QSharedPointer.
Cette fonctionnalité est activée en définissant la macro ` QT_SHAREDPOINTER_TRACK_POINTERS ` avant d’inclure l’en-tête QSharedPointer.
L'utilisation de cette fonctionnalité ne présente aucun risque, même avec du code compilé sans cette fonctionnalité. QSharedPointer veillera à ce que le pointeur soit supprimé du suiveur, même dans le code compilé sans suivi des pointeurs.
Notez toutefois que la fonctionnalité de suivi des pointeurs présente des limites en cas d'héritage multiple ou virtuel (c'est-à-dire dans les cas où deux adresses de pointeur différentes peuvent faire référence au même objet). Dans ce cas, si un pointeur est converti en un type différent et que sa valeur change, le mécanisme de suivi des pointeurs de QSharedPointer peut ne pas détecter que l’objet suivi est le même.
Voir également QSharedDataPointer, QWeakPointer, QScopedPointer et QEnableSharedFromThis.
Documentation des fonctions membres
QSharedPointer::QSharedPointer()
Crée un QSharedPointer de type null (l'objet contient une référence à nullptr).
[noexcept] template <typename X> QSharedPointer::QSharedPointer(QSharedPointer<X> &&other)
La fonction `move` construit une instance de `QSharedPointer` en la faisant pointer vers le même objet que celui vers lequel pointait ` other `.
Contraintes
Ne participe à la résolution des surcharges que si ` X* ` se convertit implicitement en ` T*`.
[explicit] template <typename X> QSharedPointer::QSharedPointer(X *ptr)
Crée un QSharedPointer pointant vers ptr. Le pointeur ptr est désormais géré par ce QSharedPointer et ne doit pas être transmis à un autre objet QSharedPointer ni supprimé en dehors de cet objet.
Depuis Qt 5.8, lorsque la dernière référence à ce QSharedPointer est détruite, ptr est supprimé par l'appel du destructeur de X(même si X ne correspond pas au paramètre de modèle de QSharedPointer T). Auparavant, c'était le destructeur de T qui était appelé.
QSharedPointer::QSharedPointer(const QWeakPointer<T> &other)
Crée un QSharedPointer en transformant la référence faible other en référence forte et en partageant son pointeur.
Si T est un type dérivé du paramètre de modèle de cette classe, QSharedPointer effectuera une conversion automatique. Sinon, vous obtiendrez une erreur de compilation.
Voir également QWeakPointer::toStrongRef().
QSharedPointer::QSharedPointer(std::nullptr_t)
Crée un QSharedPointer de valeur nulle. Cela équivaut au constructeur par défaut de QSharedPointer.
template <typename X, typename Deleter> QSharedPointer::QSharedPointer(X *ptr, Deleter d)
Crée un QSharedPointer pointant vers ptr. Le pointeur ptr est désormais géré par ce QSharedPointer et ne doit pas être transmis à un autre objet QSharedPointer ni supprimé en dehors de cet objet.
Le paramètre deleter d spécifie le déleteur personnalisé pour cet objet. Le déleteur personnalisé est appelé, à la place de l’opérateur delete(), lorsque le compteur de références fortes tombe à 0. Cela est utile, par exemple, pour appeler deleteLater() sur un QObject à la place :
static void doDeleteLater(MyObject *obj)
{
obj->deleteLater();
}
void otherFunction()
{
QSharedPointer<MyObject> obj =
QSharedPointer<MyObject>(new MyObject, doDeleteLater);
// continue using obj
obj.clear(); // calls obj->deleteLater();
}Notez que la fonction de suppression personnalisée sera appelée avec un pointeur de type X, même si le paramètre de modèle QSharedPointer T n’est pas le même.
Il est également possible de spécifier directement une fonction membre, comme dans l’exemple suivant :
QSharedPointer<MyObject> obj =
QSharedPointer<MyObject>(new MyObject, &QObject::deleteLater);Voir également clear().
template <typename Deleter> QSharedPointer::QSharedPointer(std::nullptr_t, Deleter d)
Crée un QSharedPointer de type null. Cela équivaut au constructeur par défaut de QSharedPointer.
Le paramètre deleter d spécifie le déleteur personnalisé pour cet objet. Le déleteur personnalisé est appelé, à la place de l'opérateur delete(), lorsque le compteur de références fortes tombe à 0.
QSharedPointer::QSharedPointer(const QSharedPointer<T> &other)
Crée un objet QSharedPointer qui partage le pointeur de ` other`.
Si ` T ` est un type dérivé du paramètre de modèle de cette classe, `QSharedPointer` effectuera une conversion automatique. Dans le cas contraire, vous obtiendrez une erreur de compilation.
[noexcept] QSharedPointer::QSharedPointer(QSharedPointer<T> &&other)
La fonction « move » construit une instance de QSharedPointer, de sorte qu'elle pointe vers le même objet que celui vers lequel pointait other.
QSharedPointer::~QSharedPointer()
Détruit cet objet « QSharedPointer ». S'il s'agit de la dernière référence au pointeur stocké, cette opération supprimera également le pointeur.
void QSharedPointer::clear()
Efface cet objet ` QSharedPointer `, supprimant ainsi la référence qu'il pouvait avoir vers le pointeur. S'il s'agissait de la dernière référence, le pointeur lui-même sera alors supprimé.
template <typename X> QSharedPointer<X> QSharedPointer::constCast() const &
Effectue un « const_cast » (conversion ascendante) du type de ce pointeur vers « X » et renvoie un « QSharedPointer » qui partage la référence. Cette fonction peut être utilisée pour les conversions ascendantes et descendantes, mais elle est plus utile pour les conversions ascendantes.
Voir également ` isNull()` et ` qSharedPointerConstCast()`.
[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::constCast() &&
L'QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires que *this.
Cette fonction remplace resets par *this par nullptr en cas de réussite.
Cette fonction surcharge la méthode QSharedPointer::constCast().
Cette fonction a été introduite dans Qt 6.9.
Voir également isNull() et qSharedPointerConstCast().
[static] template <typename... Args> QSharedPointer<T> QSharedPointer::create(Args &&... args)
Crée un objet ` QSharedPointer ` et alloue un nouvel élément de type ` T`. Les composants internes de ` QSharedPointer ` et l'objet sont alloués en une seule opération d'allocation de mémoire, ce qui peut contribuer à réduire la fragmentation de la mémoire dans une application s'exécutant sur une longue durée.
Cette fonction tentera d'appeler un constructeur du type T capable d'accepter tous les arguments transmis (args). Les arguments seront transmis tels quels.
T *QSharedPointer::data() const
Renvoie la valeur du pointeur référencé par cet objet.
Remarque : ne supprimez pas le pointeur renvoyé par cette fonction et ne le transmettez pas à une autre fonction susceptible de le supprimer, notamment lors de la création d'objets de type QSharedPointer ou QWeakPointer.
template <typename X> QSharedPointer<X> QSharedPointer::dynamicCast() const &
Effectue un transtypage dynamique du type de ce pointeur vers X et renvoie un QSharedPointer qui partage la référence. Si cette fonction est utilisée pour un transtypage vers le haut, alors QSharedPointer effectuera un dynamic_cast, ce qui signifie que si l'objet pointé par ce QSharedPointer n'est pas de type X, l'objet renvoyé sera null.
Remarque : le type de modèle X doit posséder les mêmes qualificatifs const et volatile que le modèle de cet objet, sinon la conversion échouera. Utilisez constCast() si vous devez supprimer ces qualificatifs.
Voir également ` qSharedPointerDynamicCast()`.
[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::dynamicCast() &&
L'objet ` QSharedPointer ` renvoyé partage la propriété avec le même ensemble de propriétaires partagés que ` *this`.
Cette fonction remplace resets *this par nullptr en cas de succès.
Cette fonction surcharge la méthode QSharedPointer::dynamicCast().
Cette fonction a été introduite dans Qt 6.9.
Voir également qSharedPointerDynamicCast().
T *QSharedPointer::get() const
Identique à data().
Cette fonction est fournie pour assurer la compatibilité de l'API avec std::shared_ptr.
bool QSharedPointer::isNull() const
Renvoie « true » si cet objet fait référence à « nullptr ».
template <typename X> QSharedPointer<X> QSharedPointer::objectCast() const &
Effectue une conversion de type ( qobject_cast()) du type de ce pointeur vers X et renvoie un QSharedPointer qui partage la référence. Si cette fonction est utilisée pour un up-cast, alors QSharedPointer effectuera une conversion de type qobject_cast, ce qui signifie que si l’objet pointé par ce QSharedPointer n’est pas de type X, l’objet renvoyé sera null.
Remarque : le type de modèle X doit posséder les mêmes qualificatifs const et volatile que le modèle de cet objet, sinon la conversion échouera. Utilisez constCast() si vous devez supprimer ces qualificatifs.
Voir également ` qSharedPointerObjectCast()`.
[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::objectCast() &&
L'QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires que *this.
Cette fonction remplace resets par *this par nullptr en cas de succès.
Cette fonction surcharge la méthode QSharedPointer::objectCast().
Cette fonction a été introduite dans Qt 6.9.
Voir également qSharedPointerObjectCast().
[noexcept, since 6.7] template <typename X> bool QSharedPointer::owner_before(const QSharedPointer<X> &other) const
[noexcept, since 6.7] template <typename X> bool QSharedPointer::owner_before(const QWeakPointer<X> &other) const
Renvoie « true » si et seulement si ce pointeur intelligent précède « other » dans un ordre basé sur la propriété défini par l'implémentation. Cet ordre est tel que deux pointeurs intelligents sont considérés comme équivalents s'ils sont tous deux vides ou s'ils possèdent tous deux le même objet (même si leur type apparent et leur pointeur sont différents).
Ces fonctions ont été introduites dans Qt 6.7.
Voir également owner_equal.
[noexcept, since 6.7] template <typename X> bool QSharedPointer::owner_equal(const QSharedPointer<X> &other) const
[noexcept, since 6.7] template <typename X> bool QSharedPointer::owner_equal(const QWeakPointer<X> &other) const
Renvoie ` true ` si et seulement si ce pointeur intelligent et ` other ` partagent la propriété.
Ces fonctions ont été introduites dans Qt 6.7.
Voir également owner_before et owner_hash.
[noexcept, since 6.7] size_t QSharedPointer::owner_hash() const
Renvoie une valeur de hachage basée sur le propriétaire pour cet objet pointeur intelligent. Les pointeurs intelligents qui sont considérés comme égaux (conformément à owner_equal) auront une valeur de hachage basée sur le propriétaire identique.
Ces fonctions ont été introduites dans Qt 6.7.
Voir également owner_equal.
void QSharedPointer::reset()
Identique à ` clear()`. Pour assurer la compatibilité avec `std::shared_ptr`.
void QSharedPointer::reset(T *t)
Réinitialise cet objet ` QSharedPointer ` pour qu'il pointe désormais vers ` t `. Équivalent à :
QSharedPointer<T> other(t); this->swap(other);template <typename Deleter> void QSharedPointer::reset(T *t, Deleter deleter)
Réinitialise cet objet ` QSharedPointer ` pour qu’il pointe désormais vers ` t `, avec le `Deleter` ` deleter`. Équivalent à :
QSharedPointer<T> other(t, deleter); this->swap(other);template <typename X> QSharedPointer<X> QSharedPointer::staticCast() const &
Effectue un transtypage statique du type de ce pointeur vers ` X ` et renvoie un ` QSharedPointer ` qui partage la référence. Cette fonction peut être utilisée pour le transtypage vers le haut comme vers le bas, mais elle est plus utile pour le transtypage vers le haut.
Remarque : le type de modèle X doit posséder les mêmes qualificatifs `const` et `volatile` que le modèle de cet objet, sinon la conversion échouera. Utilisez constCast() si vous avez besoin de supprimer ces qualificatifs.
Voir également dynamicCast(), constCast() et qSharedPointerStaticCast().
[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::staticCast() &&
L'QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires que *this.
Cette fonction remplace resets par *this par nullptr en cas de réussite.
Cette fonction surcharge la méthode QSharedPointer::staticCast().
Cette fonction a été introduite dans Qt 6.9.
Voir également dynamicCast(), constCast() et qSharedPointerStaticCast().
[noexcept] void QSharedPointer::swap(QSharedPointer<T> &other)
Permute cette instance de pointeur partagé avec celle de other. Cette opération est très rapide et ne peut jamais échouer.
QWeakPointer<T> QSharedPointer::toWeakRef() const
Renvoie un objet de référence faible qui partage le pointeur référencé par cet objet.
Voir également QWeakPointer::QWeakPointer().
QSharedPointer::operator bool() const
Renvoie « true » si le pointeur contenu n'est pas « nullptr ». Cette fonction peut être utilisée dans « if-constructs », par exemple :
if (sharedptr) { /*...*/ }Voir également isNull().
bool QSharedPointer::operator!() const
Renvoie ` true ` si cet objet fait référence à ` nullptr`. Cette fonction peut être utilisée dans ` if-constructs`, par exemple :
if (!sharedptr) { /*...*/ }Voir également isNull().
T &QSharedPointer::operator*() const
Permet d'accéder aux membres du pointeur partagé.
Si le pointeur contenu est de typ nullptr, le comportement est indéfini.
Voir aussi ` isNull()`.
T *QSharedPointer::operator->() const
Permet d'accéder aux membres du pointeur partagé.
Si le pointeur contenu est de typ nullptr, le comportement est indéfini.
Voir aussi ` isNull()`.
[noexcept] QSharedPointer<T> &QSharedPointer::operator=(QSharedPointer<T> &&other)
Cette opération attribue l'other à cette instance QSharedPointer.
[noexcept] template <typename X> QSharedPointer<T> &QSharedPointer::operator=(QSharedPointer<X> &&other)
Cette opération attribue l'other à cette instance QSharedPointer.
Contraintes
Ne participe à la résolution des surcharges que si ` X* ` se convertit implicitement en ` T*`.
QSharedPointer<T> &QSharedPointer::operator=(const QSharedPointer<T> &other)
Fait en sorte que cet objet partage le pointeur de ` other`. La référence au pointeur actuel est ignorée et, s’il s’agissait de la dernière, le pointeur sera supprimé.
Si ` T ` est un type dérivé du paramètre de modèle de cette classe, ` QSharedPointer ` effectuera une conversion automatique. Dans le cas contraire, vous obtiendrez une erreur de compilation.
QSharedPointer<T> &QSharedPointer::operator=(const QWeakPointer<T> &other)
Promeut ` other ` au rang de référence forte et fait en sorte que cet objet partage une référence au pointeur auquel il fait référence. La référence au pointeur actuelle est supprimée et, s’il s’agissait de la dernière, le pointeur sera supprimé.
Si ` T ` est un type dérivé du paramètre de modèle de cette classe, ` QSharedPointer ` effectuera une conversion automatique. Dans le cas contraire, vous obtiendrez une erreur de compilation.
Éléments non membres associés
[noexcept] template <typename T> size_t qHash(const QSharedPointer<T> &key, size_t seed = 0)
Renvoie la valeur de hachage de key, en utilisant seed comme graine pour le calcul.
template <typename X, typename T> QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &other)
Renvoie un pointeur partagé vers le pointeur détenu par ` other`, converti en type ` X`. Les types ` T ` et ` X ` doivent appartenir à une même hiérarchie pour que l'opération ` static_cast ` aboutisse.
Notez que ` X ` doit posséder les mêmes qualificatifs cv (const et volatile) que ` T `, sinon le code ne pourra pas être compilé. Utilisez ` qSharedPointerConstCast ` pour supprimer le caractère `const`.
Voir également QSharedPointer::staticCast(), qSharedPointerDynamicCast() et qSharedPointerConstCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerCast(const QWeakPointer<T> &other)
Renvoie un pointeur partagé vers le pointeur détenu par ` other`, converti en type ` X`. Les types ` T ` et ` X ` doivent appartenir à une même hiérarchie pour que l'static_cast ation aboutisse.
L’objet other est d’abord converti en une référence forte. Si cette conversion échoue (parce que l’objet vers lequel il pointe a déjà été supprimé), cette fonction renvoie un QSharedPointer nul.
Notez que X doit posséder les mêmes qualificateurs cv (const et volatile) que T, sinon le code ne pourra pas être compilé. Utilisez qSharedPointerConstCast pour supprimer le caractère « const ».
Voir également QWeakPointer::toStrongRef(), qSharedPointerDynamicCast() et qSharedPointerConstCast().
[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerCast(QSharedPointer<T> &&other)
L'QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires que other.
Cette fonction remplace resets other par nullptr en cas de succès.
Cette fonction surcharge la méthode QSharedPointer::qSharedPointerCast(const QSharedPointer<T> &other).
Cette fonction a été introduite dans Qt 6.9.
Voir également QSharedPointer::staticCast(), qSharedPointerDynamicCast() et qSharedPointerConstCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &src)
Renvoie un pointeur partagé vers le pointeur détenu par src, converti en type X. Les types T et X doivent appartenir à une même hiérarchie pour que l'const_cast e aboutisse. Les différences const et volatile entre T et X sont ignorées.
Voir également QSharedPointer::constCast(), qSharedPointerStaticCast() et qSharedPointerDynamicCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerConstCast(const QWeakPointer<T> &src)
Renvoie un pointeur partagé vers le pointeur détenu par ` src`, converti en type ` X`. Les types ` T ` et ` X ` doivent appartenir à une même hiérarchie pour que l’ const_cast ation aboutisse. Les différences ` const ` et ` volatile ` entre ` T ` et ` X ` sont ignorées.
L’objet src est d’abord converti en une référence forte. Si cette conversion échoue (parce que l’objet vers lequel il pointe a déjà été supprimé), cette fonction renvoie un QSharedPointer nul.
Voir également QWeakPointer::toStrongRef(), qSharedPointerStaticCast() et qSharedPointerDynamicCast().
[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerConstCast(QSharedPointer<T> &&src)
L'QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires que src.
En cas de réussite, cette fonction remplace resets src par nullptr.
Cette fonction surcharge la méthode QSharedPointer::qSharedPointerConstCast(const QSharedPointer<T> &src).
Cette fonction a été introduite dans Qt 6.9.
Voir également QSharedPointer::constCast(), qSharedPointerStaticCast() et qSharedPointerDynamicCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &src)
Renvoie un pointeur partagé vers le pointeur détenu par ` src`, en utilisant un transtypage dynamique vers le type ` X ` afin d’obtenir un pointeur interne du type approprié. Si l’ dynamic_cast ation échoue, l’objet renvoyé sera nul.
Notez que X doit posséder les mêmes qualificatifs cv (const et volatile) que T, sinon le code ne pourra pas être compilé. Utilisez qSharedPointerConstCast pour supprimer le caractère « const ».
Voir également QSharedPointer::dynamicCast(), qSharedPointerStaticCast() et qSharedPointerConstCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerDynamicCast(const QWeakPointer<T> &src)
Renvoie un pointeur partagé vers le pointeur détenu par ` src`, en utilisant un transtypage dynamique vers le type ` X ` afin d’obtenir un pointeur interne du type approprié. Si l’ dynamic_cast e échoue, l’objet renvoyé sera nul.
L'objet src est d'abord converti en référence forte. Si cette conversion échoue (parce que l'objet vers lequel il pointe a déjà été supprimé), cette fonction renvoie également un QSharedPointer nul.
Notez que ` X ` doit posséder les mêmes qualificateurs `cv` (`const ` et ` volatile`) que ` T `, sinon le code ne pourra pas être compilé. Utilisez ` qSharedPointerConstCast ` pour lever la contrainte `const`.
Voir également QWeakPointer::toStrongRef(), qSharedPointerStaticCast() et qSharedPointerConstCast().
[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerDynamicCast(QSharedPointer<T> &&src)
L'QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires que src.
En cas de réussite, cette fonction remplace resets src par nullptr.
Cette fonction surcharge la méthode QSharedPointer::qSharedPointerDynamicCast(const QSharedPointer<T> &src).
Cette fonction a été introduite dans Qt 6.9.
Voir également QSharedPointer::dynamicCast(), qSharedPointerStaticCast() et qSharedPointerConstCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &src)
La fonction `qSharedPointerObjectCast` permet de convertir un pointeur partagé.
Elle renvoie un pointeur partagé vers le pointeur détenu par ` src`, en utilisant une fonction ` qobject_cast()` de type ` X ` pour obtenir un pointeur interne du type approprié. Si l'qobject_cast ation échoue, l'objet renvoyé sera nul.
Notez que ` X ` doit posséder les mêmes qualificateurs `cv` (`const ` et ` volatile`) que ` T `, sinon le code ne pourra pas être compilé. Utilisez ` qSharedPointerConstCast ` pour lever la contrainte `const`.
Voir également QSharedPointer::objectCast(), qSharedPointerStaticCast() et qSharedPointerConstCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(const QWeakPointer<T> &src)
La fonction `qSharedPointerObjectCast` sert à effectuer un transtypage d'un pointeur partagé.
Elle renvoie un pointeur partagé vers le pointeur détenu par ` src`, en utilisant une qobject_cast() de type ` X ` pour obtenir un pointeur interne du type approprié. Si l'qobject_cast échoue, l'objet renvoyé sera nul.
L’objet src est d’abord converti en une référence forte. Si cette conversion échoue (car l’objet vers lequel il pointe a déjà été supprimé), cette fonction renvoie également un QSharedPointer nul.
Notez que ` X ` doit posséder les mêmes qualificateurs `cv` (`const ` et ` volatile`) que ` T `, sinon le code ne pourra pas être compilé. Utilisez ` qSharedPointerConstCast ` pour lever la contrainte `const`.
Voir également QWeakPointer::toStrongRef(), qSharedPointerStaticCast() et qSharedPointerConstCast().
template <typename X, typename T> std::shared_ptr<X> qSharedPointerObjectCast(const std::shared_ptr<T> &src)
Renvoie un pointeur partagé vers le pointeur détenu par ` src`, en utilisant une fonction ` qobject_cast()` de type ` X ` pour obtenir un pointeur interne du type approprié. Si la fonction ` qobject_cast ` échoue, l’objet renvoyé sera nul.
Notez que ` X ` doit posséder les mêmes qualificateurs `cv` (`const ` et ` volatile`) que ` T `, sinon le code ne pourra pas être compilé. Utilisez `const_pointer_cast` pour supprimer le caractère `const`.
template <typename X, typename T> std::shared_ptr<X> qSharedPointerObjectCast(std::shared_ptr<T> &&src)
Renvoie un pointeur partagé vers le pointeur détenu par ` src`, en utilisant ` qobject_cast()` sur le type ` X ` pour obtenir un pointeur interne du type approprié.
Si l'qobject_cast aboutit, la fonction renvoie un pointeur partagé valide et src est réinitialisé à null. Si l'qobject_cast échoue, l'objet renvoyé est null et src n'est pas modifié.
Notez que ` X ` doit posséder les mêmes qualificateurs `cv` (const et volatile) que ` T `, sinon le code ne pourra pas être compilé. Utilisez `const_pointer_cast` pour supprimer le qualificateur `const`.
[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(QSharedPointer<T> &&src)
L'QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires que src.
En cas de réussite, cette fonction remplace resets src par nullptr.
Cette fonction surcharge la méthode QSharedPointer::qSharedPointerObjectCast(const QSharedPointer<T> &src).
Cette fonction a été introduite dans Qt 6.9.
Voir également QSharedPointer::objectCast(), qSharedPointerStaticCast() et qSharedPointerConstCast().
[since 6.12] template <typename X, typename T> QSharedPointer<X> qSharedPointerStaticCast(const QSharedPointer<T> &other)
Renvoie un pointeur partagé vers le pointeur détenu par other, converti en type X. Les types T et X doivent appartenir à une même hiérarchie pour que la fonction static_cast aboutisse.
Notez que ` X ` doit posséder les mêmes qualificatifs `cv` (const et volatile) que ` T `, sinon le code ne se compilera pas. Utilisez ` qSharedPointerConstCast ` pour supprimer la constance.
Cette fonction a été introduite dans Qt 6.12.
Voir également QSharedPointer::staticCast(), qSharedPointerDynamicCast() et qSharedPointerConstCast().
[since 6.12] template <typename X, typename T> QSharedPointer<X> qSharedPointerStaticCast(const QWeakPointer<T> &other)
Renvoie un pointeur partagé vers le pointeur détenu par ` other`, converti en type ` X`. Les types ` T ` et ` X ` doivent appartenir à une même hiérarchie pour que l'static_cast ation aboutisse.
L’objet other est d’abord converti en une référence forte. Si cette conversion échoue (parce que l’objet vers lequel il pointe a déjà été supprimé), cette fonction renvoie un QSharedPointer nul.
Notez que ` X ` doit posséder les mêmes qualificateurs `cv` (const et volatile) que ` T `, sinon le code ne pourra pas être compilé. Utilisez ` qSharedPointerConstCast ` pour supprimer le caractère `const`.
Cette fonction a été introduite dans Qt 6.12.
Voir également QWeakPointer::toStrongRef(), qSharedPointerDynamicCast() et qSharedPointerConstCast().
[since 6.12] template <typename X, typename T> QSharedPointer<X> qSharedPointerStaticCast(QSharedPointer<T> &&other)
L'QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires partagés que other.
Cette fonction remplace resets other par nullptr en cas de succès.
Cette fonction surcharge la méthode QSharedPointer::qSharedPointerStaticCast(const QSharedPointer<T> &other).
Cette fonction a été introduite dans Qt 6.12.
Voir également QSharedPointer::staticCast(), qSharedPointerDynamicCast() et qSharedPointerConstCast().
template <typename X, typename T> std::shared_ptr<X> qobject_pointer_cast(const std::shared_ptr<T> &src)
Renvoie un pointeur partagé vers le pointeur détenu par ` src`.
Identique à qSharedPointerObjectCast(). Cette fonction est fournie à des fins de compatibilité avec la STL.
template <typename X, typename T> std::shared_ptr<X> qobject_pointer_cast(std::shared_ptr<T> &&src)
Identique à ` qSharedPointerObjectCast()`. Cette fonction est fournie à des fins de compatibilité avec la STL.
template <typename T, typename X> bool operator!=(const QSharedPointer<T> &lhs, const QSharedPointer<X> &rhs)
Renvoie « true » si « lhs » et « rhs » font référence à des pointeurs distincts.
Si le paramètre de modèle de rhs est différent de celui de lhs, QSharedPointer doit d'abord s'assurer que les types sont compatibles. Il tentera d'effectuer une static_cast ion automatique pour convertir les types T et X en leur type de pointeur composite. Si le paramètre de modèle de rhs n'est ni un type de base ni un type dérivé de celui de lhs, vous obtiendrez une erreur de compilation.
template <typename T, typename X> bool operator!=(const QSharedPointer<T> &lhs, const X *rhs)
Renvoie « true » si « lhs » et « rhs » font référence à des pointeurs distincts.
Si le paramètre de modèle de rhs est différent de celui de lhs, QSharedPointer doit d’abord s’assurer que les types sont compatibles. Il tentera d’effectuer une static_cast ation automatique pour convertir les types T et X en leur type de pointeur composite. Si le paramètre de modèle de rhs n’est ni un type de base ni un type dérivé de celui de lhs, vous obtiendrez une erreur de compilation.
template <typename T> bool operator!=(const QSharedPointer<T> &lhs, std::nullptr_t)
Renvoie ` true ` si ` lhs ` est un pointeur valide (c'est-à-dire non nul).
Voir également QSharedPointer::isNull().
template <typename T, typename X> bool operator!=(const T *lhs, const QSharedPointer<X> &rhs)
Renvoie « true » si le pointeur « lhs » n'est pas le même que celui référencé par « rhs ».
Si le paramètre de modèle de ` rhs` est différent de celui de ` lhs`, ` QSharedPointer ` doit d’abord s’assurer que les types sont compatibles. Il tentera d’effectuer une « static_cast » automatique pour convertir les types ` T ` et ` X ` en leur type de pointeur composite. Si le paramètre de modèle de ` rhs` n’est ni un type de base ni un type dérivé de celui de ` lhs`, vous obtiendrez une erreur de compilation.
template <typename T> bool operator!=(std::nullptr_t, const QSharedPointer<T> &rhs)
Renvoie ` true ` si ` rhs ` est un pointeur valide (c'est-à-dire non nul).
Voir également QSharedPointer::isNull().
template <typename T> QDebug operator<<(QDebug debug, const QSharedPointer<T> &ptr)
Écrit le pointeur suivi par ` ptr ` dans l'objet de débogage ` debug ` à des fins de débogage.
Voir également Techniques de débogage.
template <typename T, typename X> bool operator==(const QSharedPointer<T> &lhs, const QSharedPointer<X> &rhs)
Renvoie true si lhs et rhs font référence au même pointeur.
Si le paramètre de modèle de ` rhs` est différent de celui de ` lhs`, ` QSharedPointer ` doit d’abord s’assurer que les types sont compatibles. Il tentera d’effectuer une « static_cast » automatique pour convertir les types ` T ` et ` X ` en leur type de pointeur composite. Si le paramètre de modèle de ` rhs` n’est ni un type de base ni un type dérivé de celui de ` lhs`, vous obtiendrez une erreur de compilation.
template <typename T, typename X> bool operator==(const QSharedPointer<T> &lhs, const X *rhs)
Renvoie true si lhs et rhs pointent vers le même pointeur.
Si le paramètre de modèle de rhs est différent de celui de lhs, QSharedPointer doit d'abord s'assurer que les types sont compatibles. Il tentera d'effectuer une static_cast ion automatique pour convertir les types T et X en leur type de pointeur composite. Si le paramètre de modèle de rhs n'est ni un type de base ni un type dérivé de celui de lhs, vous obtiendrez une erreur de compilation.
template <typename T> bool operator==(const QSharedPointer<T> &lhs, std::nullptr_t)
Renvoie « true » si « lhs » renvoie à « nullptr ».
Voir également QSharedPointer::isNull().
template <typename T, typename X> bool operator==(const T *lhs, const QSharedPointer<X> &rhs)
Renvoie true si le pointeur lhs est le même que celui référencé par rhs.
Si le paramètre de modèle de ` rhs` est différent de celui de ` lhs`, ` QSharedPointer ` doit d'abord s'assurer que les types sont compatibles. Il tentera d'effectuer une « static_cast » automatique pour convertir les types ` T ` et ` X ` en leur type de pointeur composite. Si le paramètre de modèle de ` rhs` n'est ni un type de base ni un type dérivé de celui de ` lhs`, vous obtiendrez une erreur de compilation.
template <typename T> bool operator==(std::nullptr_t, const QSharedPointer<T> &rhs)
Renvoie « true » si « rhs » renvoie à « nullptr ».
Voir également QSharedPointer::isNull().
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.
