Namespaces
Variants

std:: atomic_... <std::shared_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::shared_ptr
Member functions
Modifiers
Observers
(C++17)
( until C++20* )
(C++26)
(C++26)
Non-member functions
(C++20)
(C++20)
(C++17)
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
atomic_xxx
functions ( until C++26* )
Helper classes
(C++20)
Deduction guides (C++17)
Défini dans l'en-tête <memory>
template < class T >
bool atomic_is_lock_free ( const std:: shared_ptr < T > * p ) ;
(1) (depuis C++11)
(déprécié en C++20)
(supprimé en C++26)
template < class T >
std:: shared_ptr < T > atomic_load ( const std:: shared_ptr < T > * p ) ;
(2) (depuis C++11)
(obsolète en C++20)
(supprimé en C++26)
template < class T >

std:: shared_ptr < T > atomic_load_explicit

( const std:: shared_ptr < T > * p, std:: memory_order mo ) ;
(3) (depuis C++11)
(obsolète en C++20)
(supprimé en C++26)
template < class T >
void atomic_store ( std:: shared_ptr < T > * p, std:: shared_ptr < T > r ) ;
(4) (depuis C++11)
(déprécié en C++20)
(supprimé en C++26)
template < class T >

void atomic_store_explicit
( std:: shared_ptr < T > * p, std:: shared_ptr < T > r,

std:: memory_order mo ) ;
(5) (depuis C++11)
(obsolète en C++20)
(supprimé en C++26)
template < class T >

std:: shared_ptr < T > atomic_exchange

( std:: shared_ptr < T > * p, std:: shared_ptr < T > r ) ;
(6) (depuis C++11)
(déprécié en C++20)
(supprimé en C++26)
template < class T >

std:: shared_ptr < T > atomic_exchange_explicit
( std:: shared_ptr < T > * p, std:: shared_ptr < T > r,

std:: memory_order mo ) ;
(7) (depuis C++11)
(obsolète en C++20)
(supprimé en C++26)
template < class T >

bool atomic_compare_exchange_weak
( std:: shared_ptr < T > * p, std:: shared_ptr < T > * expected,

std:: shared_ptr < T > desired ) ;
(8) (depuis C++11)
(obsolète en C++20)
(supprimé en C++26)
template < class T >

bool atomic_compare_exchange_strong
( std:: shared_ptr < T > * p, std:: shared_ptr < T > * expected,

std:: shared_ptr < T > desired ) ;
(9) (depuis C++11)
(obsolète en C++20)
(supprimé en C++26)
template < class T >

bool atomic_compare_exchange_strong_explicit
( std:: shared_ptr < T > * p, std:: shared_ptr < T > * expected,
std:: shared_ptr < T > desired,

std:: memory_order success, std:: memory_order failure ) ;
(10) (depuis C++11)
(obsolète en C++20)
(supprimé en C++26)
template < class T >

bool atomic_compare_exchange_weak_explicit
( std:: shared_ptr < T > * p, std:: shared_ptr < T > * expected,
std:: shared_ptr < T > desired,

std:: memory_order success, std:: memory_order failure ) ;
(11) (depuis C++11)
(déprécié en C++20)
(supprimé en C++26)

Si plusieurs threads d'exécution accèdent au même std::shared_ptr objet sans synchronisation et que l'un de ces accès utilise une fonction membre non constante de shared_ptr alors une course aux données se produira, sauf si tous ces accès sont effectués via ces fonctions, qui sont des surcharges des fonctions d'accès atomique correspondantes ( std::atomic_load , std::atomic_store , etc.).

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

1) Détermine si l'accès atomique au pointeur partagé pointé par p est sans verrouillage.
2) Équivalent à atomic_load_explicit ( p, std:: memory_order_seq_cst ) .
3) Retourne le pointeur partagé pointé par p .
Comme avec la version non spécialisée std::atomic_load_explicit , si mo est std:: memory_order_release ou std:: memory_order_acq_rel , le comportement est indéfini.
4) Équivalent à atomic_store_explicit ( p, r, std:: memory_order_seq_cst ) .
5) Stocke le pointeur partagé r dans le pointeur partagé pointé par p de manière atomique, comme si par p - > swap ( r ) .
Comme avec la version non spécialisée std::atomic_store_explicit , si mo est std:: memory_order_acquire ou std:: memory_order_acq_rel , le comportement est indéfini.
6) Équivalent à atomic_exchange_explicit ( p, r, std:: memory_order_seq_cst ) .
7) Stocke le pointeur partagé r dans le pointeur partagé pointé par p et retourne la valeur précédemment pointée par p , atomiquement, comme si par p - > swap ( r ) et retourne une copie de r après l'échange.
8) Équivalent à
atomic_compare_exchange_weak_explicit
( p, expected, desired, std:: memory_order_seq_cst ,
std:: memory_order_seq_cst ) .
9) Équivalent à
atomic_compare_exchange_strong_explicit
( p, expected, desired, std:: memory_order_seq_cst ,
std:: memory_order_seq_cst ) .
10,11) Compare les pointeurs partagés pointés par p et expected .
  • S'ils sont équivalents (stockent la même valeur de pointeur, et partent soit la propriété du même objet ou sont tous deux vides), assigne desired dans * p en utilisant les contraintes d'ordonnancement de mémoire spécifiées par success et retourne true .
  • S'ils ne sont pas équivalents, assigne * p dans * expected en utilisant les contraintes d'ordonnancement de mémoire spécifiées par failure et retourne false .
atomic_compare_exchange_weak_explicit peut échouer de manière sporadique.
Si expected est un pointeur nul, ou si failure est std:: memory_order_release ou std:: memory_order_acq_rel , le comportement est indéfini.

Si p est un pointeur nul, le comportement de ces fonctions est indéfini.

Table des matières

Paramètres

p, attendu - un pointeur vers un std::shared_ptr
r, souhaité - un std::shared_ptr
mo, succès, échec - sélecteurs d'ordre mémoire de type std::memory_order

Exceptions

Ces fonctions ne lèvent pas d'exceptions.

Valeur de retour

1) true si l'accès atomique est implémenté en utilisant des instructions sans verrou.
2,3) Une copie du pointeur partagé pointé.
4,5) (aucun)
6,7) Une copie du pointeur partagé précédemment pointé.
8-11) true si les pointeurs partagés étaient équivalents et l'échange a été effectué, false sinon.

Notes

Ces fonctions sont généralement implémentées à l'aide de mutex, stockés dans une table de hachage globale où la valeur du pointeur est utilisée comme clé.

Le Concurrency TS propose les classes de pointeurs intelligents atomiques atomic_shared_ptr et atomic_weak_ptr comme remplacement à l'utilisation de ces fonctions.

Ces fonctions ont été dépréciées en faveur des spécialisations du modèle std::atomic : std:: atomic < std:: shared_ptr > et std:: atomic < std:: weak_ptr > .

(depuis C++20)
(jusqu'à C++26)

Ces fonctions ont été supprimées en faveur des spécialisations du modèle std::atomic : std:: atomic < std:: shared_ptr > et std:: atomic < std:: weak_ptr > .

(depuis C++26)

Exemple

Cette section est incomplète
Raison : aucun exemple

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 2172 C++11 expected pouvait être un pointeur nul le comportement est indéfini dans ce cas
LWG 2980 C++11 les shared_ptr vides n'étaient jamais équivalents équivalents s'ils stockent la même valeur de pointeur

Voir aussi

(C++11)
vérifie si les opérations du type atomique sont sans verrouillage
(modèle de fonction)
(C++11) (C++11)
remplace atomiquement la valeur de l'objet atomique par un argument non atomique
(modèle de fonction)
(C++11) (C++11)
obtient atomiquement la valeur stockée dans un objet atomique
(modèle de fonction)
(C++11) (C++11)
remplace atomiquement la valeur de l'objet atomique par un argument non atomique et retourne l'ancienne valeur de l'atomique
(modèle de fonction)
(C++11) (C++11) (C++11) (C++11)
compare atomiquement la valeur de l'objet atomique avec un argument non atomique et effectue un échange atomique si égal ou un chargement atomique sinon
(modèle de fonction)