QAtomicPointer Class

if (currentValue == expectedValue) {
    currentValue = newValue;
    return true;
}
return false;

T *originalValue = currentValue;
currentValue = newValue;
return originalValue;

T *originalValue = currentValue;
currentValue += valueToAdd;
return originalValue;

Documentation des fonctions membres

[constexpr noexcept] QAtomicPointer::QAtomicPointer(T *value = nullptr)

Crée un QAtomicPointer à partir de l'value on fournie.

[noexcept] QAtomicPointer::QAtomicPointer(const QAtomicPointer<T> &other)

Crée une copie de other.

T *QAtomicPointer::fetchAndAddAcquire(qptrdiff valueToAdd)

Opération atomique « fetch-and-add ».

Lit la valeur actuelle de cette QAtomicPointer, puis ajoute valueToAdd à la valeur actuelle, en renvoyant la valeur d’origine.

Cette fonction utilise la sémantique « acquire- memory ordering », qui garantit que les accès à la mémoire suivant l’opération atomique (dans l’ordre du programme) ne peuvent pas être réordonnés avant ladite opération.

T *QAtomicPointer::fetchAndAddOrdered(qptrdiff valueToAdd)

Opération atomique « fetch-and-add ».

Lit la valeur actuelle de cette QAtomicPointer, puis ajoute valueToAdd à cette valeur, et renvoie la valeur d’origine.

Cette fonction utilise la sémantique des « ordered memory ordering », qui garantit que les accès à la mémoire avant et après l’opération atomique (dans l’ordre du programme) ne peuvent pas être réorganisés.

T *QAtomicPointer::fetchAndAddRelaxed(qptrdiff valueToAdd)

Opération atomique « fetch-and-add ».

Lit la valeur actuelle de cette QAtomicPointer, puis ajoute valueToAdd à cette valeur, et renvoie la valeur d’origine.

Cette fonction utilise une sémantique d'memory ordering « relaxed », laissant au compilateur et au processeur la liberté de réorganiser les accès à la mémoire.

T *QAtomicPointer::fetchAndAddRelease(qptrdiff valueToAdd)

Opération atomique « fetch-and-add ».

Lit la valeur actuelle de cette QAtomicPointer, puis ajoute valueToAdd à cette valeur, et renvoie la valeur d’origine.

Cette fonction utilise la sémantique « release- memory ordering », qui garantit que les accès à la mémoire antérieurs à l’opération atomique (dans l’ordre du programme) ne peuvent pas être réordonnés après l’opération atomique.

T *QAtomicPointer::fetchAndStoreAcquire(T *newValue)

Opération atomique de lecture-écriture.

Lit la valeur actuelle de cette QAtomicPointer, puis lui attribue l’ newValue, en renvoyant la valeur d’origine.

Cette fonction utilise la sémantique « acquire- memory ordering », qui garantit que les accès à la mémoire suivant l’opération atomique (dans l’ordre du programme) ne peuvent pas être réordonnés avant ladite opération.

T *QAtomicPointer::fetchAndStoreOrdered(T *newValue)

Opération atomique de lecture-écriture.

Lit la valeur actuelle de cette QAtomicPointer, puis lui attribue l’ newValue, en renvoyant la valeur d’origine.

Cette fonction utilise la sémantique des « memory ordering s ordonnés », qui garantit que les accès à la mémoire avant et après l’opération atomique (dans l’ordre du programme) ne peuvent pas être réorganisés.

T *QAtomicPointer::fetchAndStoreRelaxed(T *newValue)

Opération atomique de lecture-écriture.

Lit la valeur actuelle de cette QAtomicPointer, puis lui attribue l'newValue, en renvoyant la valeur d'origine.

Cette fonction utilise la sémantique « relaxed » de l’ memory ordering, laissant au compilateur et au processeur la liberté de réorganiser les accès mémoire.

T *QAtomicPointer::fetchAndStoreRelease(T *newValue)

Opération atomique de lecture-écriture.

Lit la valeur actuelle de cette QAtomicPointer, puis lui attribue l'newValue, en renvoyant la valeur d'origine.

Cette fonction utilise la sémantique « release- memory ordering », qui garantit que les accès à la mémoire antérieurs à l’opération atomique (dans l’ordre du programme) ne peuvent pas être réorganisés après l’opération atomique.

[static constexpr] bool QAtomicPointer::isFetchAndAddNative()

Renvoie « true » si la fonction « fetch-and-add » est implémentée à l'aide d'instructions atomiques du processeur ; sinon, elle renvoie « false ».

[static constexpr] bool QAtomicPointer::isFetchAndAddWaitFree()

Renvoie « true » si l'opération atomique « fetch-and-add » est sans attente, « false » dans le cas contraire.

[static constexpr] bool QAtomicPointer::isFetchAndStoreNative()

Renvoie « true » si la fonction « fetch-and-store » est implémentée à l'aide d'instructions atomiques du processeur ; « false » dans le cas contraire.

[static constexpr] bool QAtomicPointer::isFetchAndStoreWaitFree()

Renvoie ` true ` si l'opération atomique « fetch-and-store » est sans attente, et `false` dans le cas contraire.

[static constexpr] bool QAtomicPointer::isTestAndSetNative()

Renvoie « true » si la fonction « test-and-set » est implémentée à l'aide d'instructions atomiques du processeur ; sinon, elle renvoie « false ».

[static constexpr] bool QAtomicPointer::isTestAndSetWaitFree()

Renvoie « true » si l'opération « test-and-set » atomique est sans attente, et « false » dans le cas contraire.

T *QAtomicPointer::loadAcquire() const

Charge de manière atomique la valeur de cet QAtomicPointer en utilisant l'ordre de mémoire « Acquire ». La valeur n'est en aucun cas modifiée, mais notez qu'il n'y a aucune garantie qu'elle reste inchangée.

Voir également storeRelease() et loadRelaxed().

T *QAtomicPointer::loadRelaxed() const

Charge de manière atomique la valeur de cet objet ` QAtomicPointer ` en utilisant un ordre de mémoire assoupli. La valeur n'est en aucun cas modifiée, mais notez qu'il n'y a aucune garantie qu'elle reste inchangée.

Voir également storeRelaxed() et loadAcquire().

void QAtomicPointer::storeRelaxed(T *newValue)

Enregistre de manière atomique la valeur de ` newValue ` dans ce type atomique, en utilisant un ordre de mémoire assoupli.

Voir également ` storeRelease()` et ` loadRelaxed()`.

void QAtomicPointer::storeRelease(T *newValue)

Enregistre de manière atomique la valeur newValue dans ce type atomique, en utilisant l'ordre de mémoire « Release ».

Voir également ` storeRelaxed()` et ` loadRelaxed()`.

bool QAtomicPointer::testAndSetAcquire(T *expectedValue, T *newValue)

Test-and-set atomique.

Si la valeur actuelle de cette QAtomicPointer correspond à l’ expectedValue, les fonctions « test-and-set » attribuent l’ newValue à cette QAtomicPointer et renvoient true. Si les valeurs ne sont pas identiques, cette fonction ne fait rien et renvoie false.

Cette fonction utilise la sémantique « acquire- memory ordering », qui garantit que les accès à la mémoire suivant l’opération atomique (dans l’ordre du programme) ne peuvent pas être réordonnés avant l’opération atomique.

bool QAtomicPointer::testAndSetAcquire(T *expectedValue, T *newValue, T *&currentValue)

Test-et-initialisation atomique.

Si la valeur actuelle de cette QAtomicPointer est l’ expectedValue, les fonctions « test-and-set » attribuent l’ newValue à cette QAtomicPointer et renvoient true. Si les valeurs ne sont pas identiques, les fonctions chargent la valeur actuelle de cette QAtomicPointer dans currentValue et renvoient false.

Cette fonction utilise la sémantique « acquire » memory ordering, qui garantit que les accès à la mémoire suivant l’opération atomique (dans l’ordre du programme) ne peuvent pas être réordonnés avant l’opération atomique. Si le test-and-set échoue, la variable currentValue est chargée avec la sémantique « acquire » memory ordering.

bool QAtomicPointer::testAndSetOrdered(T *expectedValue, T *newValue)

Test-et-définition atomique.

Si la valeur actuelle de cette QAtomicPointer correspond à l’ expectedValue, les fonctions de test et de mise à jour attribuent l’ newValue à cette QAtomicPointer et renvoient true. Si les valeurs ne sont pas identiques, cette fonction ne fait rien et renvoie false.

Cette fonction utilise la sémantique « ordonnée » ( memory ordering ), qui garantit que les accès à la mémoire avant et après l’opération atomique (dans l’ordre du programme) ne peuvent pas être réorganisés.

bool QAtomicPointer::testAndSetOrdered(T *expectedValue, T *newValue, T *&currentValue)

Test-et-initialisation atomique.

Si la valeur actuelle de cette QAtomicPointer est celle de l’ expectedValue, les fonctions « test-and-set » attribuent l’ newValue à cette QAtomicPointer et renvoient true. Si les valeurs ne sont pas identiques, les fonctions chargent la valeur actuelle de cette QAtomicPointer dans currentValue et renvoient false.

Cette fonction utilise une sémantique « ordered memory ordering », qui garantit que les accès à la mémoire avant et après l’opération atomique (dans l’ordre du programme) ne peuvent pas être réorganisés. Si l’opération « test-and-set » échoue, la valeur de currentValue est chargée selon la sémantique « acquire memory ordering ».

bool QAtomicPointer::testAndSetRelaxed(T *expectedValue, T *newValue)

Test et mise à jour atomiques.

Si la valeur actuelle de cette ` QAtomicPointer ` est l'expectedValue, les fonctions « test-and-set » attribuent l'newValue à cette ` QAtomicPointer ` et renvoient `true`. Si les valeurs ne sont pas identiques, cette fonction ne fait rien et renvoie ` false`.

Cette fonction utilise une sémantique « relaxed » memory ordering, laissant au compilateur et au processeur la liberté de réorganiser les accès en mémoire.

bool QAtomicPointer::testAndSetRelaxed(T *expectedValue, T *newValue, T *&currentValue)

Test-et-mise à jour atomique.

Si la valeur actuelle de cette QAtomicPointer correspond à expectedValue, les fonctions « test-and-set » attribuent la valeur newValue à cette QAtomicPointer et renvoient true. Si les valeurs ne sont pas identiques, les fonctions chargent la valeur actuelle de cette QAtomicPointer dans currentValue et renvoient false.

Cette fonction utilise une sémantique « relaxed » memory ordering, laissant au compilateur et au processeur la liberté de réorganiser les accès à la mémoire. Si le test-and-set échoue, l’ currentValue est chargé selon une sémantique « relaxed » memory ordering.

bool QAtomicPointer::testAndSetRelease(T *expectedValue, T *newValue)

Test-and-set atomique.

Si la valeur actuelle de cette QAtomicPointer correspond à l’ expectedValue, les fonctions « test-and-set » attribuent l’ newValue à cette QAtomicPointer et renvoient true. Si les valeurs ne sont pas identiques, cette fonction ne fait rien et renvoie false.

Cette fonction utilise la sémantique « release- memory ordering », qui garantit que les accès à la mémoire antérieurs à l’opération atomique (dans l’ordre du programme) ne peuvent pas être réorganisés après l’opération atomique.

bool QAtomicPointer::testAndSetRelease(T *expectedValue, T *newValue, T *&currentValue)

Test-et-initialisation atomique.

Si la valeur actuelle de cette QAtomicPointer est celle de l’ expectedValue, les fonctions « test-and-set » attribuent l’ newValue à cette QAtomicPointer et renvoient true. Si les valeurs ne sont pas identiques, les fonctions chargent la valeur actuelle de cette QAtomicPointer dans currentValue et renvoient false.

Cette fonction utilise la sémantique « release - memory ordering », qui garantit que les accès à la mémoire antérieurs à l’opération atomique (dans l’ordre du programme) ne peuvent pas être réorganisés après l’opération atomique. Si l’opération « test-and-set » échoue, la variable currentValue est chargée selon la sémantique « relaxed- memory ordering ».

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

Attribue l'other à cet QAtomicPointer et renvoie une référence à cet QAtomicPointer.