Espaces de noms
Variantes
Affichages
Actions

std::atomic_is_lock_free<std::shared_ptr>, std::atomic_load<std::shared_ptr>, std::atomic_store<std::shared_ptr>, std::atomic_...<std::shared_ptr>

De cppreference.com
< cpp‎ | memory‎ | shared ptr

 
 
 
La gestion dynamique de la mémoire
Faible niveau de gestion de la mémoire
Répartiteurs
Original:
Allocators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
allocator
allocator_traits (C++11)
allocator_arg_t (C++11)
allocator_arg (C++11)
uses_allocator (C++11)
scoped_allocator_adaptor (C++11)
Non initialisée stockage
Original:
Uninitialized storage
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
uninitialized_copy
uninitialized_copy_n (C++11)
uninitialized_fill
uninitialized_fill_n
raw_storage_iterator
get_temporary_buffer
return_temporary_buffer
Pointeurs intelligents
Original:
Smart pointers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
unique_ptr (C++11)
shared_ptr (C++11)
weak_ptr (C++11)
auto_ptr (obsolète)
owner_less (C++11)
enable_shared_from_this (C++11)
bad_weak_ptr (C++11)
default_delete (C++11)
Soutien garbage collection
Original:
Garbage collection support
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
declare_reachable (C++11)
undeclare_reachable (C++11)
declare_no_pointers (C++11)
undeclare_no_pointers (C++11)
pointer_safety (C++11)
get_pointer_safety (C++11)
Divers
Original:
Miscellaneous
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
pointer_traits (C++11)
addressof (C++11)
align (C++11)
Bibliothèque C
Original:
C Library
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
 
std::shared_ptr
Les fonctions membres
Original:
Member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
shared_ptr::shared_ptr
shared_ptr::~shared_ptr
shared_ptr::operator=
Modificateurs
Original:
Modifiers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
shared_ptr::reset
shared_ptr::swap
Des observateurs
Original:
Observers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
shared_ptr::get
shared_ptr::operator*
shared_ptr::operator->
shared_ptr::use_count
shared_ptr::unique
shared_ptr::operator bool
shared_ptr::owner_before
Tiers fonctions
Original:
Non-member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
std::swap
make_shared
allocate_shared
static_pointer_cast
dynamic_pointer_cast
const_pointer_cast
get_deleter
operator==
operator|=
operator<
operator<=
operator>
operator>=
operator<<
atomic_is_lock_free
atomic_load
atomic_load_explicit
atomic_store
atomic_store_explicit
atomic_exchange
atomic_exchange_explicit
atomic_compare_exchange_weak
atomic_compare_exchange_strong
atomic_compare_exchange_weak_explicit
atomic_compare_exchange_strong_explicit
std::hash
 
template< class T >
bool atomic_is_lock_free( const std::shared_ptr<T>* p );
(1) (depuis C++11)
template< class T >
std::shared_ptr<T> atomic_load( const std::shared_ptr<T>* p );
(2) (depuis C++11)
template< class T >

std::shared_ptr<T> atomic_load_explicit( const shared_ptr<T>* p,

                                         std::memory_order mo );
(3) (depuis C++11)
template< class T >

void atomic_store( std::shared_ptr<T>* p,

                   std::shared_ptr<T> r );
(4) (depuis C++11)
template< class T >

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

                            std::memory_order mo);
(5) (depuis C++11)
template< class T >

std::shared_ptr<T> atomic_exchange( std::shared_ptr<T>* p,

                                    std::shared_ptr<T> r);
(6) (depuis C++11)
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)
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)
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)
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)
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)
Si plusieurs threads d'exécution accéder à l'objet référencé par le std::shared_ptr même sans synchronisation, une race de données peut se produire, à moins que tous les accès se fait par le biais de ces fonctions, qui sont des spécialisations partielles des fonctions correspondantes accès atomiques (std::atomic_load, std::atomic_store, etc.)
Original:
If multiple threads of execution access the object referenced by the same std::shared_ptr without synchronization, a data race may occur, unless all such access is performed through these functions, which are partial specializations of the corresponding atomic access functions (std::atomic_load, std::atomic_store, etc)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
{{{1}}}
Original:
{{{2}}}
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
Détermine si l'accès atomique pour le pointeur partagé par signalées à p est sans verrou .
Original:
Determines whether atomic access to the shared pointer pointed-to by p is lock-free.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
Equivalent à atomic_load_explicit(p, std::memory_order_seq_cst)
Original:
Equivalent to atomic_load_explicit(p, std::memory_order_seq_cst)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3)
Retourne le pointeur de la commune fait-par p. Comme avec le std::atomic_load_explicit non spécialisé, mo ne peut pas être std::memory_order_release ou std::memory_order_acq_rel
Original:
Returns the shared pointer pointed-to by p. As with the non-specialized std::atomic_load_explicit, mo cannot be std::memory_order_release or std::memory_order_acq_rel
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
4)
Equivalent à atomic_store_explicit(p, r, memory_order_seq_cst)
Original:
Equivalent to atomic_store_explicit(p, r, memory_order_seq_cst)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
5)
Echange les pointeurs partagés p et r, exécuter efficacement p->swap(r). Comme avec le std::atomic_store_explicit non spécialisé, mo ne peut pas être std::memory_order_acquire ou std::memory_order_acq_rel
Original:
Swaps the shared pointers p and r, effectively executing p->swap(r). As with the non-specialized std::atomic_store_explicit, mo cannot be std::memory_order_acquire or std::memory_order_acq_rel
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
6)
Equivalent à atomic_exchange_explicit(p, r, memory_order_seq_cst)
Original:
Equivalent to atomic_exchange_explicit(p, r, memory_order_seq_cst)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
7)
Echange les pointeurs partagés p et r, exécuter efficacement p->swap(r) et renvoie une copie du pointeur partagé autrefois fait à par p
Original:
Swaps the shared pointers p and r, effectively executing p->swap(r) and returns a copy of the shared pointer formerly pointed-to by p
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
8)
Equivalent à atomic_compare_exchange_weak_explicit(p, expected, desired, std::memory_order_seq_cst, std::memory_order_seq_cst)
Original:
Equivalent to atomic_compare_exchange_weak_explicit(p, expected, desired, std::memory_order_seq_cst, std::memory_order_seq_cst)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
9)
Equivalent à atomic_compare_exchange_strong_explicit(p, expected, desired, std::memory_order_seq_cst, std::memory_order_seq_cst)
Original:
Equivalent to atomic_compare_exchange_strong_explicit(p, expected, desired, std::memory_order_seq_cst, std::memory_order_seq_cst)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
10)
Compare les pointeurs partagés souligné à de p et expected. Si elles sont équivalentes (l'actionnariat de la même pointeur et se référer à la même pointeur), attribue desired en *p utilisation de la mémoire de commande contraintes spécifiées par success et retourne true. Si elles ne sont pas équivalentes, attribue *p en *expected utilisation de la mémoire de commande contraintes spécifiées par failure et retours false .
Original:
Compares the shared pointers pointed-to by p and expected. If they are equivalent (share ownership of the same pointer and refer to the same pointer), assigns desired into *p using the memory ordering constraints specified by success and returns true. If they are not equivalent, assigns *p into *expected using the memory ordering constraints specified by failure and returns false.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
11)
Identique à 10), mais peut échouer faussement .
Original:
Same as 10), but may fail spuriously.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Toutes ces fonctions invoquer un comportement indéterminé si p est un pointeur nul .
Original:
All these functions invoke undefined behavior if p is a null pointer.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Sommaire

[modifier] Paramètres

p, expected -
un pointeur vers une std::shared_ptr
Original:
a pointer to a std::shared_ptr
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
r, desired - a std::shared_ptr
mo, success, failure -
mémoire de commande sélecteurs de std::memory_order type
Original:
memory ordering selectors of type std::memory_order
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Exceptions

Ces fonctions ne lèvent pas d'exceptions .
Original:
These functions do not throw exceptions.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Retour

1)
true si l'accès est implémenté en utilisant atomique sans verrou instructions
Original:
true if atomic access is implemented using lock-free instructions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
@ 2,3 @ Une copie du pointeur pointée partagée .
Original:
@2,3@ A copy of the pointed-to shared pointer.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
@ 4,5 @ rien
Original:
@4,5@ nothing
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
@ 6,7 @ Une copie du pointeur auparavant signalé à partager
Original:
@6,7@ A copy of the formerly pointed-to shared pointer
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
@ @ 8,9,10,11 true si les pointeurs partagés sont équivalentes et l'échange a été effectué, false autrement .
Original:
@8,9,10,11@ true if the shared pointers were equivalent and the exchange was performed, false otherwise.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Voir aussi

vérifie si les opérations du type atomique sont sans verrou
Original:
checks if the atomic type's operations are lock-free
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction générique) [edit]
remplace atomiquement la valeur de l'objet atomique avec un argument non-atomique
Original:
atomically replaces the value of the atomic object with a non-atomic argument
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction générique) [edit]
obtient atomiquement la valeur stockée dans un objet atomique
Original:
atomically obtains the value stored in an atomic object
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction générique) [edit]
remplace atomiquement la valeur de l'objet atomique avec des non-atomique argument et retourne l'ancienne valeur de la bombe atomique
Original:
atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction générique) [edit]
compare atomiquement la valeur de l'objet atomique non atomique avec l'argument, et réalise un échange atomique égal ou si la charge atomique sinon
Original:
atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction générique) [edit]