Espaces de noms
Variantes

    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
    See More

    This page has been machine-translated from the English version of the wiki using Google Translate.

    The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

    Click here for the English version of this page

    <metanoindex/>

     
    C++
     
    Bibliothèque d'utilitaires
     
    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
     
    <tbody> </tbody>
    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.

    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.

    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.

    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.

    Voir aussi

    (C++11)
    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]
    (C++11)
    (C++11)
    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]
    (C++11)
    (C++11)
    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]
    (C++11)
    (C++11)
    remplace atomiquement la valeur de l'objet atomique avec des non-atomique argument et retourne l'ancienne valeur de l'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]
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    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]