QExplicitlySharedDataPointer Class

Documentation des fonctions membres

[noexcept] QExplicitlySharedDataPointer::QExplicitlySharedDataPointer()

Crée un objet `QExplicitlySharedDataPointer` initialisé avec ` nullptr ` en tant que pointeur `d`.

[explicit noexcept] QExplicitlySharedDataPointer::QExplicitlySharedDataPointer(T *data)

Crée un objet `QExplicitlySharedDataPointer` dont le pointeur `d` est défini sur ` data ` et incrémente le compteur de références de ` data`.

[noexcept] template <typename X> QExplicitlySharedDataPointer::QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<X> &o)

Ce constructeur de copie se distingue en ce qu’il permet à ` o ` d’être un pointeur vers des données partagées d’un type différent, à condition que l’objet de données partagé soit compatible.

Par défaut, le pointeur `d` de ` o ` (de type ` \a X *`) est implicitement converti en type ` \a T *` ; le résultat de cette conversion est attribué au pointeur `d` de `this`, et le compteur de références de l’objet de données partagé est incrémenté.

[noexcept] QExplicitlySharedDataPointer::QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T> &o)

Ce constructeur de copie standard attribue au pointeur `d` de `this` la valeur du pointeur `d` de ` o ` et incrémente le compteur de références de l'objet de données partagé.

[noexcept] QExplicitlySharedDataPointer::QExplicitlySharedDataPointer(QExplicitlySharedDataPointer<T> &&o)

Crée par « move » une instance de `QExplicitlySharedDataPointer`, en la faisant pointer vers le même objet que celui vers lequel pointait ` o `.

QExplicitlySharedDataPointer::~QExplicitlySharedDataPointer()

Diminue le compteur de références de l'objet de données partagé. Si le compteur de références atteint 0, l'objet de données partagé est supprimé. Celui-ci est alors détruit.

[protected] T *QExplicitlySharedDataPointer::clone()

Crée et renvoie une copie profonde des données actuelles. Cette fonction est appelée par detach() lorsque le compteur de références est supérieur à 1, afin de créer la nouvelle copie. Cette fonction utilise l'opérateur new et appelle le constructeur de copie du type T.

Voir QSharedDataPointer<T>::clone() pour savoir comment l’utiliser.

[noexcept] const T *QExplicitlySharedDataPointer::constData() const

Renvoie un pointeur const vers l'objet de données partagé.

Voir aussi data().

[noexcept] T *QExplicitlySharedDataPointer::data() const

Renvoie un pointeur vers l'objet de données partagé.

void QExplicitlySharedDataPointer::detach()

Si le compteur de références de l'objet de données partagé est supérieur à 1, cette fonction crée une copie profonde de l'objet de données partagé et attribue la valeur du pointeur `d` de celui-ci à la copie.

Étant donné que la classe ` QExplicitlySharedDataPointer ` n'effectue pas de copie automatique lors des opérations d'écriture, contrairement aux membres de la classe ` QSharedDataPointer `, la fonction `detach() ` n' est appelée automatiquement nulle part dans les fonctions membres de cette classe. Si vous constatez que vous appelez la fonction `detach()` à plusieurs endroits dans votre code, envisagez d'utiliser plutôt la classe ` QSharedDataPointer `.

[noexcept, since 6.0] T *QExplicitlySharedDataPointer::get() const

Identique à ` data()`. Cette fonction est fournie à des fins de compatibilité avec la STL.

Cette fonction a été introduite dans Qt 6.0.

[noexcept, since 6.0] void QExplicitlySharedDataPointer::reset(T *ptr = nullptr)

Définit le pointeur `d` de cet objet sur ` ptr ` et incrémente le compteur de références de ` ptr` si ` ptr ` n'est pas ` nullptr`. Le compteur de références de l'ancien objet de données partagées est décrémenté, et l'objet est supprimé si le compteur de références atteint 0.

Cette fonction a été introduite dans Qt 6.0.

[noexcept] void QExplicitlySharedDataPointer::swap(QExplicitlySharedDataPointer<T> &other)

Permute ce pointeur de données explicitement partagé avec other. Cette opération est très rapide et ne rate jamais.

[noexcept] T *QExplicitlySharedDataPointer::take()

Renvoie un pointeur vers l'objet partagé, puis réinitialise celui-ci à la valeur nullptr. (En d'autres termes, cette fonction définit le pointeur d de this à la valeur nullptr.)

[noexcept] QExplicitlySharedDataPointer::operator bool() const

Renvoie ` true ` si le pointeur `d` de cet objet n' est pas nul.

[noexcept] bool QExplicitlySharedDataPointer::operator!() const

Renvoie ` true ` si le pointeur `d` de cette variable est ` nullptr`.

T &QExplicitlySharedDataPointer::operator*() const

Permet d'accéder aux membres de l'objet de données partagé.

[noexcept] T *QExplicitlySharedDataPointer::operator->()

Permet d'accéder aux membres de l'objet de données partagé.

[noexcept] T *QExplicitlySharedDataPointer::operator->() const

Permet d'accéder de manière constante aux membres de l'objet de données partagé.

[noexcept] QExplicitlySharedDataPointer<T> &QExplicitlySharedDataPointer::operator=(QExplicitlySharedDataPointer<T> &&other)

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

[noexcept] QExplicitlySharedDataPointer<T> &QExplicitlySharedDataPointer::operator=(T *o)

Définit le pointeur `d` de cet objet sur ` o ` et incrémente le compteur de références de ` o`. Le compteur de références de l'ancien objet de données partagées de cet objet est décrémenté. Si le compteur de références de l'ancien objet de données partagées devient égal à 0, cet objet est supprimé.

[noexcept] QExplicitlySharedDataPointer<T> &QExplicitlySharedDataPointer::operator=(const QExplicitlySharedDataPointer<T> &o)

Définit le pointeur `d` de cet objet sur le pointeur `d` de ` o ` et incrémente le compteur de références de l'objet de données partagé. Le compteur de références de l'ancien objet de données partagé de cet objet est décrémenté. Si le compteur de références de l'ancien objet de données partagé devient égal à 0, l'ancien objet de données partagé est supprimé.