Namensräume
Varianten

    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>

    Aus 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++
     
    Utilities-Bibliothek
     
    Dynamische Speicherverwaltung
    Low-Level-Speicherverwaltung
    Zuweiser
    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)
    Initialisierter Speicher
    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
    Intelligente Zeiger
    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(veraltet)
    owner_less(C++11)
    enable_shared_from_this(C++11)
    bad_weak_ptr(C++11)
    default_delete(C++11)
    Garbage Collection Unterstützung
    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)
    Verschiedenes
    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)
    C-Bibliothek
    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
    Member-Funktionen
    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=
    Modifiers
    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
    Beobachter
    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
    Non-Member-Funktionen
    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) (seit C++11)
    template< class T > std::shared_ptr<T> atomic_load( const std::shared_ptr<T>* p );
    		 (2) (seit C++11)
    template< class T > std::shared_ptr<T> atomic_load_explicit( const shared_ptr<T>* p, std::memory_order mo );
    		 (3) (seit C++11)
    template< class T > void atomic_store( std::shared_ptr<T>* p, std::shared_ptr<T> r );
    		 (4) (seit C++11)
    template< class T > void atomic_store_explicit( std::shared_ptr<T>* p, shared_ptr<T> r, std::memory_order mo);
    		 (5) (seit C++11)
    template< class T > std::shared_ptr<T> atomic_exchange( std::shared_ptr<T>* p, std::shared_ptr<T> r);
    		 (6) (seit 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) (seit 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) (seit 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) (seit 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) (seit 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) (seit C++11)
    Wenn mehrere Ausführungs-Threads Zugriff auf das Objekt von der gleichen std::shared_ptr ohne Synchronisation verwiesen wird, kann ein Daten-Rennen auftreten, wenn alle diesen Zugang durch diese Funktionen, die eine partielle Spezialisierungen der entsprechenden atomaren Zugriff Funktionen (std::atomic_load, std::atomic_store, etc) sind durchgeführt wird
    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)
    Bestimmt, ob atomaren Zugriff auf den freigegebenen Zeiger von p zu spitz ist lock-free .
    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)
    Entspricht 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)
    Gibt die geteilten Zeiger gezeigt-bis p. Wie bei dem nicht spezialisierten std::atomic_load_explicit kann mo nicht std::memory_order_release sein oder 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)
    Entspricht 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)
    Tauscht die gemeinsame Zeiger p und r, effektiv ausführt p->swap(r). Wie bei dem nicht spezialisierten std::atomic_store_explicit kann mo nicht std::memory_order_acquire sein oder 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)
    Entspricht 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)
    Tauscht die gemeinsame Zeiger p und r, effektiv ausführt p->swap(r) und gibt eine Kopie des freigegebenen Zeiger früher spitz-durch 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)
    Entspricht 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)
    Entspricht 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)
    Vergleicht die freigegebenen Zeiger wies-bis p und expected. Wenn sie gleichwertig sind (Anteilsbesitz des gleichen Zeiger und beziehen sich auf die gleichen Zeiger), ordnet desired in *p mit der Speicher-Bestellung Zwänge success und kehrt true angegeben. Wenn sie nicht gleich sind, weist *p in *expected mit der Speicher-Bestellung Zwänge failure angegeben und kehrt 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)
    Gleiche wie 10), kann aber fälschlicherweise nicht .
    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.
    All diese Funktionen aufzurufen undefinierten Verhalten, wenn p ist ein Null-Zeiger .
    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.

    Parameter

    p, expected -
    einen Zeiger auf eine 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 -
    Speicher Bestellung Selektoren des Typs std::memory_order
    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.

    Ausnahmen

    Diese Funktionen sind keine Ausnahmen .
    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.

    Zurückzukehren

    1)
    true wenn atomaren Zugriff erfolgt über Lock-freie Anweisungen
    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 @ Eine Kopie des spitzen-to gemeinsamen Zeiger .
    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 @ nichts
    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 @ Eine Kopie der ehemals spitz-auf freigegebene Zeiger
    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 wenn die freigegebenen Zeiger gleichwertig waren und der Austausch durchgeführt wurde, false sonst .
    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.

    Siehe auch

    (C++11)
    		 Prüft, ob die Operationen eines atomaren Typs lock-frei sind
    (Funktions-Template) [edit]
    (C++11)
    (C++11)
    ersetzt atomar den Wert des atomaren Objekts durch ein nichtatomares Argument
    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.

    (Funktions-Template) [edit]
    (C++11)
    (C++11)
    erhält atomar den Wert eines atomaren Objekts
    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.

    (Funktions-Template) [edit]
    (C++11)
    (C++11)
    atomar ersetzt den Wert des atomaren Objekt mit nicht-elementare Argument und gibt den alten Wert des atomaren
    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.

    (Funktions-Template) [edit]
    (C++11)
    (C++11)
    (C++11)
    (C++11)
    atomar vergleicht den Wert des atomaren Objekt mit nicht-elementare Argument und führt atomaren Austausch wenn gleiche oder atomare Last, wenn nicht
    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.

    (Funktions-Template) [edit]