Namespaces
Variants

std:: atomic <std::weak_ptr>

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::weak_ptr
Défini dans l'en-tête <memory>
template < class T > struct std:: atomic < std:: weak_ptr < T >> ;
(depuis C++20)

La spécialisation partielle du modèle de std::atomic pour std:: weak_ptr < T > permet aux utilisateurs de manipuler les objets weak_ptr de manière atomique.

Si plusieurs threads d'exécution accèdent au même std::weak_ptr sans synchronisation et que l'un de ces accès utilise une fonction membre non constante de weak_ptr , alors une course aux données se produira, sauf si tous ces accès sont effectués via une instance de std:: atomic < std:: weak_ptr > .

Les incréments associés du use_count sont garantis comme faisant partie de l'opération atomique. Les décréments associés du use_count sont séquencés après l'opération atomique, mais ne sont pas requis d'en faire partie, sauf pour le changement du use_count lors du remplacement de expected dans un CAS échoué. Toute suppression et désallocation associées sont séquencées après l'étape de mise à jour atomique et ne font pas partie de l'opération atomique.

Notez que le bloc de contrôle utilisé par std::weak_ptr et std::shared_ptr est thread-safe : différents objets std::weak_ptr non atomiques peuvent être accédés via des opérations modifiables, telles que operator = ou reset , simultanément par plusieurs threads, même lorsque ces instances sont des copies ou partagent le même bloc de contrôle en interne.

Le type T peut être un type incomplet.

Table des matières

Types membres

Type de membre Définition
value_type std:: weak_ptr < T >

Fonctions membres

Toutes les fonctions non spécialisées de std::atomic sont également fournies par cette spécialisation, et aucune fonction membre supplémentaire n'est présente.

atomic<weak_ptr<T>>:: atomic

constexpr atomic ( ) noexcept = default ;
(1)
atomic ( std:: weak_ptr < T > desired ) noexcept ;
(2)
atomic ( const atomic & ) = delete ;
(3)
1) Initialise le weak_ptr<T> sous-jacent avec la valeur par défaut.
2) Initialise le weak_ptr<T> sous-jacent avec une copie de desired . Comme pour tout type std::atomic , l'initialisation n'est pas une opération atomique.
3) Les types atomiques ne sont pas copiables/déplaçables.

atomic<weak_ptr<T>>:: operator=

void operator = ( const atomic & ) = delete ;
(1)
void operator = ( std:: weak_ptr < T > desired ) noexcept ;
(2)
1) Les types atomiques ne sont pas assignables par copie/déplacement.
2) Assignation de valeur, équivalent à store ( desired ) .

atomic<weak_ptr<T>>:: is_lock_free

bool is_lock_free ( ) const noexcept ;

Retourne true si les opérations atomiques sur tous les objets de ce type sont sans verrouillage, false sinon.

atomic<weak_ptr<T>>:: store

void store ( std:: weak_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;

Remplace atomiquement la valeur de * this par la valeur de desired comme par p. swap ( desired ) où p est le std:: weak_ptr < T > sous-jacent. La mémoire est ordonnée selon order . Le comportement est indéfini si order est std::memory_order_consume , std::memory_order_acquire , ou std::memory_order_acq_rel .

atomic<weak_ptr<T>>:: load

Retourne atomiquement une copie du std:: weak_ptr < T > sous-jacent. La mémoire est ordonnée selon order . Le comportement est indéfini si order est std::memory_order_release ou std::memory_order_acq_rel .

atomic<weak_ptr<T>>:: operator std::weak_ptr<T>

operator std:: weak_ptr < T > ( ) const noexcept ;

Équivalent à return load ( ) ; .

atomic<weak_ptr<T>>:: exchange

Remplace atomiquement le std:: weak_ptr < T > sous-jacent par desired comme par p. swap ( desired ) où p est le std:: weak_ptr < T > sous-jacent, et retourne une copie de la valeur que p avait immédiatement avant l'échange. La mémoire est ordonnancée selon order . Il s'agit d'une opération atomique de lecture-modification-écriture.

atomic<weak_ptr<T>>:: compare_exchange_weak, compare_exchange_strong

bool compare_exchange_strong ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order success, std:: memory_order failure ) noexcept ;
(1)
bool compare_exchange_weak ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order success, std:: memory_order failure ) noexcept ;
(2)
bool compare_exchange_strong ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;
(3)
bool compare_exchange_weak ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;
(4)
1) Si le std:: weak_ptr < T > sous-jacent stocke la même valeur de pointeur que expected et partage la propriété avec celui-ci, ou si le sous-jacent et expected sont tous deux vides, assigne desired au std:: weak_ptr < T > sous-jacent, retourne true , et ordonne la mémoire selon success ; sinon assigne le std:: weak_ptr < T > sous-jacent à expected , retourne false , et ordonne la mémoire selon failure . Le comportement est indéfini si failure est std::memory_order_release ou std::memory_order_acq_rel . En cas de succès, l'opération est une opération atomique de lecture-modification-écriture sur * this et expected n'est pas accédé après la mise à jour atomique. En cas d'échec, l'opération est une opération de chargement atomique sur * this et expected est mis à jour avec la valeur existante lue depuis l'objet atomique. Cette mise à jour du use_count de expected fait partie de cette opération atomique, bien que l'écriture elle-même (et toute désallocation/destruction ultérieure) ne soit pas requise de l'être.
2) Identique à (1) , mais peut également échouer de manière sporadique.
3) Équivalent à : return compare_exchange_strong ( expected, desired, order, fail_order ) ; , où fail_order est identique à order sauf que std::memory_order_acq_rel est remplacé par std::memory_order_acquire et std::memory_order_release est remplacé par std::memory_order_relaxed .
4) Équivalent à : return compare_exchange_weak ( expected, desired, order, fail_order ) ; , où fail_order est identique à order sauf que std::memory_order_acq_rel est remplacé par std::memory_order_acquire et std::memory_order_release est remplacé par std::memory_order_relaxed .

atomic<weak_ptr<T>>:: wait

void wait ( std:: weak_ptr < T > old
std:: memory_order order = std:: memory_order_seq_cst ) const noexcept ;

Effectue une opération d'attente atomique.

Compare load ( order ) avec old et s'ils sont équivalents, bloque jusqu'à ce que * this soit notifié par notify_one() ou notify_all() . Ceci est répété jusqu'à ce que load ( order ) change. Cette fonction est garantie de ne retourner que si la valeur a changé, même si l'implémentation sous-jacente se débloque de manière sporadique.

La mémoire est ordonnée selon order . Le comportement est indéfini si order est std::memory_order_release ou std::memory_order_acq_rel .

Notes : deux std::weak_ptr sont équivalents s'ils stockent le même pointeur et partagent la propriété ou sont tous deux vides.

atomic<weak_ptr<T>>:: notify_one

void notify_one ( ) noexcept ;

Effectue une opération de notification atomique.

S'il existe un thread bloqué dans des opérations d'attente atomique (c'est-à-dire wait() ) sur * this , alors débloque au moins un de ces threads ; sinon ne fait rien.

atomic<weak_ptr<T>>:: notify_all

void notify_all ( ) noexcept ;

Effectue une opération de notification atomique.

Débloque tous les threads bloqués dans des opérations d'attente atomique (c'est-à-dire wait() ) sur * this , s'il y en a ; sinon ne fait rien.

Constantes membres

La seule constante membre standard std::atomic is_always_lock_free est également fournie par cette spécialisation.

atomic<weak_ptr<T>>:: is_always_lock_free

static constexpr bool is_always_lock_free = /*implementation-defined*/ ;

Exemple

Cette section est incomplète
Raison : aucun exemple

Voir aussi

(C++11)
modèle de classe atomic et spécialisations pour bool, types entiers, types à virgule flottante, (depuis C++20) et types pointeurs
(modèle de classe)