QAtomicInteger Class

MySharedType &MySharedType::operator=(const MySharedType &other)
{
    (void) other.data->atomicInt.ref();
    if (!data->atomicInt.deref()) {
        // The last reference has been released
        delete d;
    }
    d = other.d;
    return *this;
}

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

int originalValue = currentValue;
currentValue = newValue;
return originalValue;

int originalValue = currentValue;
currentValue += valueToAdd;
return originalValue;

Documentation sur les fonctions membres

[constexpr noexcept] QAtomicInteger::QAtomicInteger(T value = 0)

Crée un objet `QAtomicInteger` avec l'value` spécifié.

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

Crée une copie de other.

bool QAtomicInteger::deref()

Décrémente de manière atomique la valeur de cette QAtomicInteger. Renvoie « true » si la nouvelle valeur est différente de zéro, « false » dans le cas contraire.

Cette fonction utilise la sémantique ordonnée de ` 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éordonnés.

Voir également ` ref()` et ` operator--()`.

T QAtomicInteger::fetchAndAddAcquire(T valueToAdd)

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

Lit la valeur actuelle de cette QAtomicInteger, puis ajoute valueToAdd à cette valeur, et renvoie 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 l’opération atomique.

Voir également ` operator+=()` et ` fetchAndSubAcquire()`.

T QAtomicInteger::fetchAndAddOrdered(T valueToAdd)

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

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

Cette fonction utilise la sémantique des « ordered memory ordering 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.

Voir également ` operator+=()` et ` fetchAndSubOrdered()`.

T QAtomicInteger::fetchAndAddRelaxed(T valueToAdd)

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

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

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

Voir également ` operator+=()` et ` fetchAndSubRelaxed()`.

T QAtomicInteger::fetchAndAddRelease(T valueToAdd)

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

Lit la valeur actuelle de c QAtomicInteger, puis ajoute l’ valueToAdd e à 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.

Voir également ` operator+=()` et ` fetchAndSubRelease()`.

T QAtomicInteger::fetchAndAndAcquire(T valueToAnd)

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

Lit la valeur actuelle de cette QAtomicInteger, puis effectue une opération AND bit à bit entre valueToAnd et la valeur actuelle, renvoyant ainsi 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 l’opération atomique.

Voir également ` operator&=()`.

T QAtomicInteger::fetchAndAndOrdered(T valueToAnd)

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

Lit la valeur actuelle de cette QAtomicInteger, puis effectue un ET binaire entre valueToAnd et la valeur actuelle, et renvoie la valeur d’origine.

Cette fonction utilise la sémantique des « ord 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.

Voir également ` operator&=()`.

T QAtomicInteger::fetchAndAndRelaxed(T valueToAnd)

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

Lit la valeur actuelle de cette QAtomicInteger, puis effectue une opération AND bit à bit entre valueToAnd et la valeur actuelle, renvoyant ainsi la valeur d’origine.

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

Voir également ` operator&=()`.

T QAtomicInteger::fetchAndAndRelease(T valueToAnd)

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

Lit la valeur actuelle de cett QAtomicInteger, puis effectue une opération AND bit à bit entre valueToAnd et la valeur actuelle, renvoyant ainsi la valeur d’origine.

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

Voir également operator&=().

T QAtomicInteger::fetchAndOrAcquire(T valueToOr)

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

Lit la valeur actuelle de cett QAtomicInteger, puis effectue un OU bit à bit entre valueToOr et la valeur actuelle, renvoyant ainsi 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 l’opération atomique.

Voir également operator|=().

T QAtomicInteger::fetchAndOrOrdered(T valueToOr)

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

Lit la valeur actuelle de cette QAtomicInteger, puis effectue une opération OR bit à bit entre valueToOr et la valeur actuelle, renvoyant ainsi la valeur d’origine.

Cette fonction utilise la sémantique des « ordres d'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.

Voir également ` operator|=()`.

T QAtomicInteger::fetchAndOrRelaxed(T valueToOr)

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

Lit la valeur actuelle de cette QAtomicInteger, puis effectue une opération OR bit à bit entre valueToOr et la valeur actuelle, renvoyant ainsi la valeur d’origine.

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

Voir également ` operator|=()`.

T QAtomicInteger::fetchAndOrRelease(T valueToOr)

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

Lit la valeur actuelle de cette QAtomicInteger, puis effectue une opération OU bit à bit entre valueToOr et la valeur actuelle, renvoyant ainsi 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.

Voir également ` operator|=()`.

T QAtomicInteger::fetchAndStoreAcquire(T newValue)

Opération atomique de lecture-écriture.

Lit la valeur actuelle de cette QAtomicInteger, 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 QAtomicInteger::fetchAndStoreOrdered(T newValue)

Opération atomique de lecture-écriture.

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

Cette fonction utilise la sémantique des « ordered memory ordering 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 QAtomicInteger::fetchAndStoreRelaxed(T newValue)

Opération atomique de lecture et d'écriture.

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

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

T QAtomicInteger::fetchAndStoreRelease(T newValue)

Opération atomique de lecture-écriture.

Lit la valeur actuelle de cet QAtomicInteger, 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.

T QAtomicInteger::fetchAndSubAcquire(T valueToSub)

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

Lit la valeur actuelle de cette QAtomicInteger, puis soustrait valueToSub de cette valeur, et renvoie 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 l’opération atomique.

Voir également ` operator-=()` et ` fetchAndAddAcquire()`.

T QAtomicInteger::fetchAndSubOrdered(T valueToSub)

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

Lit la valeur actuelle de cette QAtomicInteger, puis soustrait valueToSub de 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.

Voir également operator-=() et fetchAndAddOrdered().

T QAtomicInteger::fetchAndSubRelaxed(T valueToSub)

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

Lit la valeur actuelle de cette QAtomicInteger, puis soustrait valueToSub de 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 mémoire.

Voir également ` operator-=()` et ` fetchAndAddRelaxed()`.

T QAtomicInteger::fetchAndSubRelease(T valueToSub)

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

Lit la valeur actuelle de cette QAtomicInteger, puis soustrait l'valueToSub e de cette valeur, renvoyant ainsi 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.

Voir également operator-=() et fetchAndAddRelease().

T QAtomicInteger::fetchAndXorAcquire(T valueToXor)

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

Lit la valeur actuelle de cette QAtomicInteger, puis effectue une opération XOR bit à bit entre valueToXor et la valeur actuelle, renvoyant ainsi 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 l'opération atomique.

Voir également operator^=().

T QAtomicInteger::fetchAndXorOrdered(T valueToXor)

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

Lit la valeur actuelle de cette QAtomicInteger, puis effectue une opération XOR bit à bit entre valueToXor et la valeur actuelle, renvoyant ainsi la valeur d’origine.

Cette fonction utilise la sémantique des « ord 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.

Voir également ` operator^=()`.

T QAtomicInteger::fetchAndXorRelaxed(T valueToXor)

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

Lit la valeur actuelle de cett QAtomicInteger, puis effectue une opération XOR bit à bit entre valueToXor et la valeur actuelle, renvoyant ainsi la valeur d’origine.

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

Voir également ` operator^=()`.

T QAtomicInteger::fetchAndXorRelease(T valueToXor)

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

Lit la valeur actuelle de cett QAtomicInteger, puis effectue une opération XOR bit à bit entre valueToXor et la valeur actuelle, renvoyant ainsi 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.

Voir également operator^=().

[static constexpr] bool QAtomicInteger::isFetchAndAddNative()

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

[static constexpr] bool QAtomicInteger::isFetchAndAddWaitFree()

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

[static constexpr] bool QAtomicInteger::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 QAtomicInteger::isFetchAndStoreWaitFree()

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

[static constexpr] bool QAtomicInteger::isReferenceCountingNative()

Renvoie « true » si le comptage des références est mis en œuvre à l'aide d'instructions atomiques du processeur, « false » dans le cas contraire.

[static constexpr] bool QAtomicInteger::isReferenceCountingWaitFree()

Renvoie « true » si le comptage atomique des références est sans attente, « false » dans le cas contraire.

[static constexpr] bool QAtomicInteger::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 QAtomicInteger::isTestAndSetWaitFree()

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

T QAtomicInteger::loadAcquire() const

Charge de manière atomique la valeur de cet QAtomicInteger 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 le reste.

Voir également storeRelaxed() et loadRelaxed().

T QAtomicInteger::loadRelaxed() const

Charge de manière atomique la valeur de cet QAtomicInteger 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().

bool QAtomicInteger::ref()

Incrémente de manière atomique la valeur de cette QAtomicInteger. Renvoie « true » si la nouvelle valeur est différente de zéro, « false » dans le cas contraire.

Cette fonction utilise la sémantique ordonnée de ` 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éordonnés.

Voir également ` deref()` et ` operator++()`.

void QAtomicInteger::storeRelaxed(T newValue)

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

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

void QAtomicInteger::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 ` loadAcquire()`.

bool QAtomicInteger::testAndSetAcquire(T expectedValue, T newValue)

Test-and-set atomique.

Si la valeur actuelle de ce QAtomicInteger correspond à l’ expectedValue, les fonctions « test-and-set » attribuent l’ newValue à ce QAtomicInteger 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 QAtomicInteger::testAndSetAcquire(T expectedValue, T newValue, T &currentValue)

Test-et-initialisation atomique.

Si la valeur actuelle de cette QAtomicInteger correspond à l’ expectedValue, les fonctions « test-and-set » attribuent l’ newValue à cette QAtomicInteger et renvoient true. Si les valeurs ne sont pas identiques, les fonctions chargent la valeur actuelle de cette QAtomicInteger 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 QAtomicInteger::testAndSetOrdered(T expectedValue, T newValue)

Test-and-set atomique.

Si la valeur actuelle de cette QAtomicInteger correspond à l’ expectedValue, les fonctions « test-and-set » attribuent l’ newValue à cette QAtomicInteger 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 QAtomicInteger::testAndSetOrdered(T expectedValue, T newValue, T &currentValue)

Test-et-mise à zéro atomique.

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

Cette fonction utilise la 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 variable currentValue est chargée selon la sémantique « acquire » ( memory ordering ).

bool QAtomicInteger::testAndSetRelaxed(T expectedValue, T newValue)

Test-and-set atomique.

Si la valeur actuelle de cet QAtomicInteger correspond à l’ expectedValue, les fonctions « test-and-set » attribuent l’ newValue à cet QAtomicInteger 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 à la mémoire.

bool QAtomicInteger::testAndSetRelaxed(T expectedValue, T newValue, T &currentValue)

Test-and-set atomique.

Si la valeur actuelle de cette QAtomicInteger est celle de expectedValue, les fonctions « test-and-set » attribuent la valeur de newValue à cette QAtomicInteger et renvoient true. Si les valeurs ne sont pas identiques, les fonctions chargent la valeur actuelle de cette QAtomicInteger 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 en mémoire. Si le test-and-set échoue, l’ currentValue est chargée selon la sémantique « relaxed memory ordering ».

bool QAtomicInteger::testAndSetRelease(T expectedValue, T newValue)

Test-and-set atomique.

Si la valeur actuelle de cette QAtomicInteger est la expectedValue, les fonctions « test-and-set » attribuent la newValue à cette QAtomicInteger 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éordonnés après l’opération atomique.

bool QAtomicInteger::testAndSetRelease(T expectedValue, T newValue, T &currentValue)

Test-et-initialisation atomique.

Si la valeur actuelle de cette QAtomicInteger correspond à l’ expectedValue, les fonctions « test-and-set » attribuent la newValue à cette QAtomicInteger et renvoient true. Si les valeurs ne sont pas identiques, les fonctions chargent la valeur actuelle de cette QAtomicInteger 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 valeur de currentValue est chargée selon la sémantique « relaxed- memory ordering ».

QAtomicInteger::operator T() const

Charge de manière atomique la valeur de cet QAtomicInteger en utilisant, si possible, un ordre de mémoire séquentiellement cohérent ; sinon, l'ordre « Acquire ». La valeur n'est en aucun cas modifiée, mais notez qu'il n'y a aucune garantie qu'elle le reste.

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

T QAtomicInteger::operator&=(T value)

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

Lit la valeur actuelle de cette QAtomicInteger, puis effectue un AND bit à bit entre value et la valeur actuelle, renvoyant ainsi la nouvelle valeur.

Cette fonction utilise, si possible, un ordre de mémoire séquentiellement cohérent ; sinon, elle utilise l’ordre « ordonné ».

Voir également fetchAndAndOrdered().

T QAtomicInteger::operator++()

Incrémente de manière atomique la valeur de cet élément « QAtomicInteger ». Renvoie la nouvelle valeur de cet élément atomique.

Cette fonction utilise un ordre de mémoire séquentiellement cohérent si possible ; sinon, elle utilise l’ordre « ordonné ».

Voir également ref(), operator++(int) et operator--().

T QAtomicInteger::operator++(int)

Incrémente de manière atomique la valeur de cet élément « QAtomicInteger ». Renvoie l'ancienne valeur de cet élément atomique.

Cette fonction utilise un ordre de mémoire séquentiellement cohérent si possible ; sinon, elle utilise l’ordre « Ordered ».

Voir également ref(), operator++() et operator--(int).

T QAtomicInteger::operator+=(T value)

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

Lit la valeur actuelle de cette QAtomicInteger, puis ajoute value à la valeur actuelle, et renvoie la nouvelle valeur.

Cette fonction utilise un ordre de mémoire séquentiellement cohérent si possible ; sinon, elle utilise l’ordre « ordonné ».

Voir également fetchAndAddOrdered() et operator-=().

T QAtomicInteger::operator--()

Décrémente de manière atomique la valeur de cet élément « QAtomicInteger ». Renvoie la nouvelle valeur de cet élément atomique.

Cette fonction utilise un ordonnancement de mémoire séquentiellement cohérent si possible ; sinon, elle utilise l’ordonnancement « ordonné ».

Voir également deref(), operator--(int) et operator++().

T QAtomicInteger::operator--(int)

Décrémente de manière atomique la valeur de cet élément « QAtomicInteger ». Renvoie l'ancienne valeur de cet élément atomique.

Cette fonction utilise un ordre de mémoire séquentiellement cohérent si possible ; sinon, elle utilise l'ordre « ordonné ».

Voir également deref(), operator--() et operator++(int).

T QAtomicInteger::operator-=(T value)

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

Lit la valeur actuelle de cette é QAtomicInteger, puis soustrait value de cette valeur, et renvoie la nouvelle valeur.

Cette fonction utilise un ordre de mémoire séquentiellement cohérent si possible ; sinon, elle utilise l'ordre « ordonné ».

Voir également ` fetchAndSubOrdered()` et ` operator+=()`.

QAtomicInteger<T> &QAtomicInteger::operator=(T)

Enregistre de manière atomique l'autre valeur dans ce type atomique en utilisant, si possible, un ordre de mémoire séquentiellement cohérent ; sinon, l'ordre « Release ». Cette fonction renvoie une référence à cet objet.

Voir également storeRelaxed() et storeRelease().

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

Attribue la valeur « other » à « QAtomicInteger » et renvoie une référence à « QAtomicInteger ».

T QAtomicInteger::operator^=(T value)

Opération atomique « XOR et récupération ».

Lit la valeur actuelle de cette é QAtomicInteger, puis effectue une opération XOR bit à bit entre value et la valeur actuelle, et renvoie la nouvelle valeur.

Cette fonction utilise un ordre de mémoire séquentiellement cohérent si possible ; sinon, elle utilise l’ordre « ordonné ».

Voir également fetchAndXorOrdered().

T QAtomicInteger::operator|=(T value)

Opération atomique « OR-AND-FETCH ».

Lit la valeur actuelle de cette é QAtomicInteger, puis effectue une opération OR bit à bit entre value et la valeur actuelle, renvoyant ainsi la nouvelle valeur.

Cette fonction utilise un ordre de mémoire séquentiellement cohérent si possible ; sinon, elle utilise l’ordre « ordonné ».

Voir également fetchAndOrOrdered().

while (!condition)
    ;

while (!condition)
    qYieldCpu();

while (true) {
    while (!readOnlyCondition(atomic))
        qYieldCpu();
    if (modify(atomic))
        break;
}