QSharedPointer Class
template <typename T> class QSharedPointerLa classe QSharedPointer contient une référence forte à un pointeur partagé. Plus d'informations...
| En-tête : | #include <QSharedPointer> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Core)target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake : | QT += core |
Cette classe est fortement comparable.
Cette classe est fortement comparable à QSharedPointer<X>, X*, et std::nullptr_t.
X et T sont des types compatibles, ce qui signifie qu'ils sont identiques ou que l'un est un type de base de l'autre.
Remarque : toutes les fonctions de cette classe sont réentrantes.
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) |
Non-membres apparentés
| size_t | qHash(const QSharedPointer<T> &key, size_t seed = 0) |
| QSharedPointer<X> | qSharedPointerCast(const QSharedPointer<T> &other) |
(since 6.9) QSharedPointer<X> | qSharedPointerCast(QSharedPointer<T> &&other) |
| QSharedPointer<X> | qSharedPointerCast(const QWeakPointer<T> &other) |
| QSharedPointer<X> | qSharedPointerConstCast(const QSharedPointer<T> &src) |
(since 6.9) QSharedPointer<X> | qSharedPointerConstCast(QSharedPointer<T> &&src) |
| QSharedPointer<X> | qSharedPointerConstCast(const QWeakPointer<T> &src) |
| QSharedPointer<X> | qSharedPointerDynamicCast(const QSharedPointer<T> &src) |
(since 6.9) QSharedPointer<X> | qSharedPointerDynamicCast(QSharedPointer<T> &&src) |
| QSharedPointer<X> | qSharedPointerDynamicCast(const QWeakPointer<T> &src) |
| QSharedPointer<X> | qSharedPointerObjectCast(const QSharedPointer<T> &src) |
(since 6.9) QSharedPointer<X> | qSharedPointerObjectCast(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) |
| 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++. Il se comporte exactement comme un pointeur normal à des fins normales, y compris le respect de la constance.
QSharedPointer supprime le pointeur qu'il détient lorsqu'il sort du champ d'application, à condition qu'aucun autre objet QSharedPointer n'y fasse référence.
Un objet QSharedPointer peut être créé à partir d'un pointeur normal, d'un autre objet QSharedPointer ou en promouvant un objet QWeakPointer en référence forte.
Sécurité des threads
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é par plusieurs threads en même temps sans synchronisation.
Différents objets QSharedPointer et QWeakPointer peuvent être accédés en toute sécurité par plusieurs threads en même temps. Le mécanisme de comptage des références est atomique et aucune synchronisation manuelle n'est nécessaire.
Il convient de noter que, bien que la valeur du pointeur puisse être accessible de cette manière (c'est-à-dire par plusieurs threads en même temps, sans synchronisation), QSharedPointer et QWeakPointer ne fournissent aucune garantie quant à l'objet pointé. Les règles spécifiques de sécurité des threads et de réentrance pour cet objet s'appliquent toujours.
Autres classes de pointeurs
Qt XML fournit également deux autres classes de pointeurs : QPointer et QSharedDataPointer. Elles sont incompatibles l'une avec l'autre, car chacune a un cas d'utilisation très différent.
QSharedPointer détient un pointeur partagé au moyen d'un compteur de référence externe (c'est-à-dire un compteur de référence placé à l'extérieur de l'objet). Comme son nom l'indique, la valeur du pointeur est partagée entre toutes les instances de QSharedPointer et QWeakPointer. Le contenu de l'objet pointé par le pointeur ne doit cependant 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 faire des copies de l'objet pointé.
QSharedDataPointerQSharedPointer, en revanche, détient un pointeur sur des données partagées (c'est-à-dire une classe dérivée de QSharedData). Il le fait au moyen d'un compte de référence interne, placé dans la classe de base QSharedData. Cette classe peut donc se détacher en fonction du type d'accès aux données gardées : s'il s'agit d'un accès non-const, elle crée une copie atomiquement pour que l'opération se termine.
QExplicitlySharedDataPointer est une variante de QSharedDataPointer, sauf qu'il ne se détache que si QExplicitlySharedDataPointer::detach() est explicitement appelé (d'où son nom).
QScopedPointer contient simplement un pointeur sur un objet alloué au tas et le supprime dans son destructeur. Cette classe est utile lorsqu'un objet doit être alloué au tas et supprimé, mais pas plus. QScopedPointer est légère, elle n'utilise pas de structure supplémentaire ou de comptage de références.
Enfin, QPointer contient un pointeur sur un objet dérivé de QObject, mais il le fait faiblement. QWeakPointer a la même fonctionnalité, mais son utilisation pour cette fonction est dépréciée.
Suivi optionnel des pointeurs
Une caractéristique de QSharedPointer qui peut être activée à la compilation à des fins de débogage est un mécanisme de suivi des pointeurs. Lorsqu'il est activé, QSharedPointer enregistre dans un ensemble global tous les pointeurs qu'il suit. Cela permet de détecter des erreurs telles que l'affectation du même pointeur à deux objets QSharedPointer.
Cette fonction est activée en définissant la macro QT_SHAREDPOINTER_TRACK_POINTERS avant d'inclure l'en-tête QSharedPointer.
Il est possible d'utiliser cette fonction en toute sécurité, même avec du code compilé sans cette fonction. QSharedPointer s'assurera que le pointeur est supprimé du traceur, même dans le cas d'un code compilé sans suivi de pointeur.
Notez cependant que la fonctionnalité de suivi des pointeurs a des limitations en ce qui concerne l'héritage multiple ou virtuel (c'est-à-dire dans les cas où deux adresses de pointeurs 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 nul (l'objet contient une référence à nullptr).
[noexcept] template <typename X> QSharedPointer::QSharedPointer(QSharedPointer<X> &&other)
Move-construit une instance de QSharedPointer, la faisant pointer sur le même objet que other.
Contraintes
Ne participe à la résolution de surcharge que si X* se convertit implicitement en T*.
[explicit] template <typename X> QSharedPointer::QSharedPointer(X *ptr)
Crée un QSharedPointer qui pointe vers ptr. Le pointeur ptr est géré par ce QSharedPointer et ne doit pas être transmis à un autre objet QSharedPointer ou supprimé en dehors de cet objet.
Depuis Qt 5.8, lorsque la dernière référence à ce QSharedPointer est détruite, ptr sera supprimé en appelant le destructeur de X(même si X n'est pas le même que le paramètre template de QSharedPointer T). Auparavant, le destructeur de T était appelé.
QSharedPointer::QSharedPointer(const QWeakPointer<T> &other)
Crée un QSharedPointer en promouvant 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 modèle de cette classe, QSharedPointer effectuera une conversion automatique. Sinon, vous obtiendrez une erreur du compilateur.
Voir aussi QWeakPointer::toStrongRef().
QSharedPointer::QSharedPointer(std::nullptr_t)
Crée un QSharedPointer qui est nul. Ceci est équivalent au constructeur par défaut de QSharedPointer.
template <typename X, typename Deleter> QSharedPointer::QSharedPointer(X *ptr, Deleter d)
Crée un QSharedPointer qui pointe vers ptr. Le pointeur ptr est géré par ce QSharedPointer et ne doit pas être transmis à un autre objet QSharedPointer ou supprimé en dehors de cet objet.
Le paramètre deleter d spécifie le deleter personnalisé pour cet objet. La fonction de suppression personnalisée est appelée, au lieu de l'opérateur delete(), lorsque le nombre de références fortes tombe à 0. Ceci 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 une fonction membre directement, comme dans :
QSharedPointer<MyObject> obj = QSharedPointer<MyObject>(new MyObject, &QObject::deleteLater);
Voir aussi clear().
template <typename Deleter> QSharedPointer::QSharedPointer(std::nullptr_t, Deleter d)
Crée un QSharedPointer qui est nul. Ceci est équivalent au constructeur par défaut de QSharedPointer.
Le paramètre deleter d spécifie le deleter personnalisé pour cet objet. Le suppresseur personnalisé est appelé, au lieu de l'opérateur delete(), lorsque le nombre 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 modèle de cette classe, QSharedPointer effectuera une conversion automatique. Sinon, vous obtiendrez une erreur du compilateur.
[noexcept] QSharedPointer::QSharedPointer(QSharedPointer<T> &&other)
Move-construit une instance de QSharedPointer, en la faisant pointer sur le même objet que other.
QSharedPointer::~QSharedPointer()
Détruit cet objet QSharedPointer. S'il s'agit de la dernière référence au pointeur stocké, le pointeur sera également supprimé.
void QSharedPointer::clear()
Efface cet objet QSharedPointer, en supprimant la référence qu'il a pu avoir au pointeur. S'il s'agit de la dernière référence, le pointeur lui-même sera supprimé.
template <typename X> QSharedPointer<X> QSharedPointer::constCast() const &
Effectue un const_cast du type de ce pointeur vers X et renvoie un QSharedPointer qui partage la référence. Cette fonction peut être utilisée pour la fonte ascendante et descendante, mais elle est plus utile pour la fonte ascendante.
Voir aussi isNull() et qSharedPointerConstCast().
[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::constCast() &&
L'adresse QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires partagés que *this.
Cette fonction resets *this à nullptr en cas de succès.
Cette fonction surcharge QSharedPointer::constCast().
Cette fonction a été introduite dans Qt 6.9.
Voir aussi 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 éléments internes de QSharedPointer et l'objet sont alloués en une seule fois, ce qui peut contribuer à réduire la fragmentation de la mémoire dans une application de longue durée.
Cette fonction tentera d'appeler un constructeur pour le type T qui peut accepter tous les arguments passés (args). Les arguments seront parfaitement transmis.
T *QSharedPointer::data() const
Renvoie la valeur du pointeur référencé par cet objet.
Note : ne pas supprimer le pointeur retourné par cette fonction ou le passer à une autre fonction qui pourrait le supprimer, y compris la création d'objets QSharedPointer ou QWeakPointer.
template <typename X> QSharedPointer<X> QSharedPointer::dynamicCast() const &
Effectue une conversion 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 effectuer une fonte ascendante, 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 retourné sera nul.
Remarque : le modèle de type X doit avoir les mêmes qualificatifs const et volatile que le modèle de cet objet, sinon le cast échouera. Utilisez constCast() si vous avez besoin de supprimer ces qualificatifs.
Voir aussi qSharedPointerDynamicCast().
[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::dynamicCast() &&
L'adresse QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires partagés que *this.
Cette fonction resets *this à nullptr en cas de succès.
Cette fonction surcharge QSharedPointer::dynamicCast().
Cette fonction a été introduite dans Qt 6.9.
Voir aussi qSharedPointerDynamicCast().
T *QSharedPointer::get() const
Identique à data().
Cette fonction est fournie à des fins de compatibilité 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 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 effectuer un up-cast, alors QSharedPointer effectuera un qobject_cast, ce qui signifie que si l'objet pointé par ce QSharedPointer n'est pas de type X, l'objet retourné sera nul.
Remarque : le modèle de type X doit avoir les mêmes qualificatifs const et volatile que le modèle de cet objet, sinon le cast échouera. Utilisez constCast() si vous avez besoin de supprimer ces qualificatifs.
Voir aussi qSharedPointerObjectCast().
[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::objectCast() &&
L'adresse QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires partagés que *this.
Cette fonction resets *this à nullptr en cas de succès.
Cette fonction surcharge QSharedPointer::objectCast().
Cette fonction a été introduite dans Qt 6.9.
Voir aussi 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 le propriétaire et défini par l'implémentation. L'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 aussi 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 aussi 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 se comparent de manière égale (conformément à owner_equal) auront un hachage identique basé sur le propriétaire.
Ces fonctions ont été introduites dans Qt 6.7.
Voir aussi owner_equal.
void QSharedPointer::reset()
Identique à clear(). Pour la compatibilité avec std::shared_ptr.
void QSharedPointer::reset(T *t)
Réinitialise l'objet QSharedPointer pour qu'il pointe sur 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 vers t, avec le Deleter deleter. Équivalent à :
QSharedPointer<T> other(t, deleter); this->swap(other);
template <typename X> QSharedPointer<X> QSharedPointer::staticCast() const &
Effectue une conversion 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 les castings ascendants et descendants, mais elle est plus utile pour les castings ascendants.
Remarque : le modèle de type X doit avoir 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 aussi dynamicCast(), constCast(), et qSharedPointerCast().
[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::staticCast() &&
L'adresse QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires partagés que *this.
Cette fonction resets *this à nullptr en cas de succès.
Cette fonction surcharge QSharedPointer::staticCast().
Cette fonction a été introduite dans Qt 6.9.
Voir aussi dynamicCast(), constCast(), et qSharedPointerCast().
[noexcept] void QSharedPointer::swap(QSharedPointer<T> &other)
Échange cette instance de pointeur partagé avec other. Cette opération est très rapide et n'échoue jamais.
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, comme :
if (sharedptr) { /*...*/ }
Voir aussi isNull().
bool QSharedPointer::operator!() const
Renvoie true si cet objet fait référence à nullptr. Cette fonction peut être utilisée dans if-constructs, comme :
if (!sharedptr) { /*...*/ }
Voir aussi isNull().
T &QSharedPointer::operator*() const
Permet d'accéder aux membres du pointeur partagé.
Si le pointeur contenu est nullptr, le comportement est indéfini.
Voir également isNull().
T *QSharedPointer::operator->() const
Permet d'accéder aux membres du pointeur partagé.
Si le pointeur contenu est nullptr, le comportement est indéfini.
Voir également isNull().
[noexcept] QSharedPointer<T> &QSharedPointer::operator=(QSharedPointer<T> &&other)
Move-assigne other à cette instance QSharedPointer.
[noexcept] template <typename X> QSharedPointer<T> &QSharedPointer::operator=(QSharedPointer<X> &&other)
Move-assigne other à cette instance QSharedPointer.
Contraintes
Ne participe à la résolution des surcharges que si X* est implicitement converti en T*.
QSharedPointer<T> &QSharedPointer::operator=(const QSharedPointer<T> &other)
Fait partager à cet objet le pointeur de other. La référence actuelle du pointeur est supprimée et, s'il s'agit de la dernière, le pointeur sera supprimé.
Si T est un type dérivé du paramètre modèle de cette classe, QSharedPointer effectuera une conversion automatique. Sinon, vous obtiendrez une erreur du compilateur.
QSharedPointer<T> &QSharedPointer::operator=(const QWeakPointer<T> &other)
Promeut other en référence forte et fait en sorte que cet objet partage une référence avec le pointeur auquel il fait référence. La référence actuelle du pointeur est supprimée et, s'il s'agit de la dernière, le pointeur sera supprimé.
Si T est un type dérivé du paramètre modèle de cette classe, QSharedPointer effectuera une conversion automatique. Sinon, vous obtiendrez une erreur du compilateur.
Non-membres apparentés
[noexcept] template <typename T> size_t qHash(const QSharedPointer<T> &key, size_t seed = 0)
Renvoie la valeur de hachage pour key, en utilisant seed comme base de calcul.
template <typename X, typename T> QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &other)
Renvoie un pointeur partagé vers le pointeur détenu par other, coulé dans le type X. Les types T et X doivent appartenir à une même hiérarchie pour que static_cast réussisse.
Notez que X doit avoir les mêmes qualificateurs cv (const et volatile) que T, ou le code ne pourra pas être compilé. Utilisez qSharedPointerConstCast pour vous débarrasser de la contrainte.
Voir aussi QSharedPointer::staticCast(), qSharedPointerDynamicCast(), et qSharedPointerConstCast().
[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerCast(QSharedPointer<T> &&other)
L'adresse QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires partagés que other.
Cette fonction resets other à nullptr en cas de succès.
Cette fonction surcharge QSharedPointer::qSharedPointerCast(const QSharedPointer<T> &other).
Cette fonction a été introduite dans Qt 6.9.
Voir aussi 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, coulé dans le type X. Les types T et X doivent appartenir à une même hiérarchie pour que static_cast réussisse.
L'objet other est d'abord converti en référence forte. Si cette conversion échoue (parce que l'objet vers lequel elle pointe a déjà été supprimé), cette fonction renvoie un objet null QSharedPointer.
Notez que X doit avoir les mêmes qualificateurs cv (const et volatile) que T, ou le code ne pourra pas être compilé. Utilisez qSharedPointerConstCast pour vous débarrasser de la contrainte.
Voir aussi QWeakPointer::toStrongRef(), 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, coulé dans le type X. Les types T et X doivent appartenir à une même hiérarchie pour que const_cast réussisse. Les différences entre const et volatile et entre T et X sont ignorées.
Voir aussi QSharedPointer::constCast(), qSharedPointerCast() et qSharedPointerDynamicCast().
[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerConstCast(QSharedPointer<T> &&src)
L'adresse QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires partagés que src.
Cette fonction resets src à nullptr en cas de succès.
Cette fonction surcharge QSharedPointer::qSharedPointerConstCast(const QSharedPointer<T> &src).
Cette fonction a été introduite dans Qt 6.9.
Voir aussi QSharedPointer::constCast(), qSharedPointerCast(), 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, coulé dans le type X. Les types T et X doivent appartenir à une même hiérarchie pour que const_cast réussisse. Les différences entre const et volatile et entre T et X sont ignorées.
L'objet src est d'abord converti en référence forte. Si cette conversion échoue (parce que l'objet vers lequel elle pointe a déjà été supprimé), cette fonction renvoie une valeur nulle QSharedPointer.
Voir aussi QWeakPointer::toStrongRef(), qSharedPointerCast() 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 cast dynamique vers le type X pour obtenir un pointeur interne du type approprié. Si dynamic_cast échoue, l'objet renvoyé sera nul.
Notez que X doit avoir les mêmes qualificateurs cv (const et volatile) que T, ou le code ne pourra pas être compilé. Utilisez qSharedPointerConstCast pour supprimer la constance.
Voir aussi QSharedPointer::dynamicCast(), qSharedPointerCast(), et qSharedPointerConstCast().
[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerDynamicCast(QSharedPointer<T> &&src)
L'adresse QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires partagés que src.
Cette fonction resets src à nullptr en cas de succès.
Cette fonction surcharge QSharedPointer::qSharedPointerDynamicCast(const QSharedPointer<T> &src).
Cette fonction a été introduite dans Qt 6.9.
Voir aussi QSharedPointer::dynamicCast(), qSharedPointerCast(), 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 cast dynamique vers le type X pour obtenir un pointeur interne du type approprié. Si dynamic_cast é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 elle pointe a déjà été supprimé), cette fonction renvoie également un objet null QSharedPointer.
Notez que X doit avoir les mêmes qualificateurs cv (const et volatile) que T, ou le code ne pourra pas être compilé. Utilisez qSharedPointerConstCast pour vous débarrasser de la constance.
Voir aussi QWeakPointer::toStrongRef(), qSharedPointerCast(), et qSharedPointerConstCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &src)
La fonction qSharedPointerObjectCast permet de mouler un pointeur partagé.
Elle renvoie un pointeur partagé au pointeur détenu par src, en utilisant un qobject_cast() de type X pour obtenir un pointeur interne du type approprié. Si qobject_cast échoue, l'objet renvoyé sera nul.
Notez que X doit avoir les mêmes qualificateurs cv (const et volatile) que T, ou le code ne pourra pas être compilé. Utilisez qSharedPointerConstCast pour supprimer la constance.
Voir aussi QSharedPointer::objectCast(), qSharedPointerCast(), et qSharedPointerConstCast().
[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(QSharedPointer<T> &&src)
L'adresse QSharedPointer renvoyée partage la propriété avec le même ensemble de propriétaires partagés que src.
Cette fonction resets src à nullptr en cas de succès.
Cette fonction surcharge QSharedPointer::qSharedPointerObjectCast(const QSharedPointer<T> &src).
Cette fonction a été introduite dans Qt 6.9.
Voir aussi QSharedPointer::objectCast(), qSharedPointerCast(), et qSharedPointerConstCast().
template <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(const QWeakPointer<T> &src)
La fonction qSharedPointerObjectCast permet de mouler un pointeur partagé.
Elle renvoie un pointeur partagé au pointeur détenu par src, en utilisant un qobject_cast() de type X pour obtenir un pointeur interne du type approprié. Si qobject_cast échoue, l'objet retourné sera nul.
L'objet src est d'abord converti en référence forte. Si cette conversion échoue (parce que l'objet vers lequel elle pointe a déjà été supprimé), cette fonction renvoie également un objet null QSharedPointer.
Notez que X doit avoir les mêmes qualificateurs cv (const et volatile) que T, ou le code ne pourra pas être compilé. Utilisez qSharedPointerConstCast pour vous débarrasser de la constance.
Voir aussi QWeakPointer::toStrongRef(), qSharedPointerCast(), 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 un qobject_cast() de type X pour obtenir un pointeur interne du type approprié. Si qobject_cast échoue, l'objet retourné sera nul.
Notez que X doit avoir les mêmes qualificateurs cv (const et volatile) que T, ou le code ne pourra pas être compilé. Utilisez const_pointer_cast pour supprimer la constance.
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 un qobject_cast() de type X pour obtenir un pointeur interne du type approprié.
Si qobject_cast réussit, la fonction renvoie un pointeur partagé valide et src est réinitialisé à null. Si qobject_cast échoue, l'objet renvoyé sera nul et src ne sera pas modifié.
Notez que X doit avoir les mêmes qualificateurs cv (const et volatile) que T, ou le code ne pourra pas être compilé. Utilisez const_pointer_cast pour supprimer la constance.
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 pour la compatibilité STL.
template <typename X, typename T> std::shared_ptr<X> qobject_pointer_cast(std::shared_ptr<T> &&src)
Identique à qSharedPointerObjectCast(). Cette fonction est fournie pour la compatibilité 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 qu'il s'agit de types compatibles. Il tentera d'effectuer une opération automatique static_cast pour convertir les types T et X en leur type de pointeur composite. Si le paramètre de gabarit de rhs n'est pas un type de base ou un type dérivé de celui de lhs, vous obtiendrez une erreur du compilateur.
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 qu'il s'agit de types compatibles. Il tentera d'effectuer une opération automatique static_cast pour convertir les types T et X en leur type de pointeur composite. Si le paramètre de gabarit de rhs n'est pas un type de base ou un type dérivé de celui de lhs, vous obtiendrez une erreur du compilateur.
template <typename T> bool operator!=(const QSharedPointer<T> &lhs, std::nullptr_t)
Renvoie true si lhs fait référence à un pointeur valide (c'est-à-dire non nul).
Voir aussi 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 qu'il s'agit de types compatibles. Il tentera d'effectuer une opération automatique static_cast pour convertir les types T et X en leur type de pointeur composite. Si le paramètre de gabarit de rhs n'est pas un type de base ou un type dérivé de celui de lhs, vous obtiendrez une erreur du compilateur.
template <typename T> bool operator!=(std::nullptr_t, const QSharedPointer<T> &rhs)
Renvoie true si rhs fait référence à un pointeur valide (c'est-à-dire non nul).
Voir aussi 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 aussi 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 qu'il s'agit de types compatibles. Il tentera d'effectuer une opération automatique static_cast pour convertir les types T et X en leur type de pointeur composite. Si le paramètre de gabarit de rhs n'est pas un type de base ou un type dérivé de celui de lhs, vous obtiendrez une erreur du compilateur.
template <typename T, typename X> bool operator==(const QSharedPointer<T> &lhs, const 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 qu'il s'agit de types compatibles. Il tentera d'effectuer une opération automatique static_cast pour convertir les types T et X en leur type de pointeur composite. Si le paramètre de gabarit de rhs n'est pas un type de base ou un type dérivé de celui de lhs, vous obtiendrez une erreur du compilateur.
template <typename T> bool operator==(const QSharedPointer<T> &lhs, std::nullptr_t)
Renvoie true si lhs fait référence à nullptr.
Voir aussi 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 qu'il s'agit de types compatibles. Il tentera d'effectuer une opération automatique static_cast pour convertir les types T et X en leur type de pointeur composite. Si le paramètre de gabarit de rhs n'est pas un type de base ou un type dérivé de celui de lhs, vous obtiendrez une erreur du compilateur.
template <typename T> bool operator==(std::nullptr_t, const QSharedPointer<T> &rhs)
Renvoie true si rhs fait référence à nullptr.
Voir aussi 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.
