Espaços nominais
Variantes
    Ações

      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++
       
      Biblioteca de utilitários
      Digite apoio (basic types, RTTI, type traits)
      Gerenciamento de memória dinâmica
      De tratamento de erros
      Utilidades do programa
      Variadic funções
      Data e hora
      Objetos de função
      (C++11)
      (C++11)
      Os operadores relacionais
      Original:
      Relational operators
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      rel_ops::operator!=
      rel_ops::operator>
      rel_ops::operator<=
      rel_ops::operator>=
      Pares e tuplas
      Original:
      Pairs and tuples
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      (C++11)
      (C++11)
      (C++11)
      Troque, avançar e avançar
      Original:
      Swap, forward and move
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      (C++11)
      (C++11)
      (C++11)
      (C++11)
       
      Gerenciamento de memória dinâmica
      Gerenciamento de memória de baixo nível
      Alocadores
      Original:
      Allocators
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      Uninitialized armazenamento
      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.
      (C++11)
      Ponteiros inteligentes
      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.
      (C++11)
      (C++11)
      (C++11)
      (obsoleta)
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      Apoio a coleta de lixo
      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.
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      Diversos
      Original:
      Miscellaneous
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      (C++11)
      (C++11)
      (C++11)
      C Library
      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
      Funções de membro
      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=
      Modificadores
      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
      Observadores
      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
      Não-membros funções
      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.
       
      <tbody> </tbody>
      template< class T > bool atomic_is_lock_free( const std::shared_ptr<T>* p );
      		 (1) (desde C++11)
      template< class T > std::shared_ptr<T> atomic_load( const std::shared_ptr<T>* p );
      		 (2) (desde C++11)
      template< class T > std::shared_ptr<T> atomic_load_explicit( const shared_ptr<T>* p, std::memory_order mo );
      		 (3) (desde C++11)
      template< class T > void atomic_store( std::shared_ptr<T>* p, std::shared_ptr<T> r );
      		 (4) (desde C++11)
      template< class T > void atomic_store_explicit( std::shared_ptr<T>* p, shared_ptr<T> r, std::memory_order mo);
      		 (5) (desde C++11)
      template< class T > std::shared_ptr<T> atomic_exchange( std::shared_ptr<T>* p, std::shared_ptr<T> r);
      		 (6) (desde 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) (desde 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) (desde 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) (desde 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) (desde 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) (desde C++11)
      Se vários segmentos de execução acessar o objeto referenciado pelo std::shared_ptr mesmo sem sincronização, uma corrida de dados pode ocorrer, a não ser que todo o acesso seja realizado através destas funções, que são especializações parciais das correspondentes funções de acesso atômicas (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)
      Determina se o acesso atômica para o ponteiro compartilhado apontado por p é lock-livre.
      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)
      Equivalente a 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)
      Retorna o ponteiro compartilhado apontado por p. Tal como acontece com o std::atomic_load_explicit não especializado, mo não pode ser 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)
      Equivalente a 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)
      Trocas os ponteiros compartilhados p e r, efetivamente executando p->swap(r). Tal como acontece com o std::atomic_store_explicit não especializado, mo não pode ser 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)
      Equivalente a 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)
      Trocas os ponteiros compartilhados p e r, efetivamente executando p->swap(r) e retorna uma cópia do ponteiro compartilhado anteriormente apontado por 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)
      Equivalente a 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)
      Equivalente a 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)
      Compara os ponteiros compartilhados apontado por p e expected. Se eles são equivalentes (participação acionária do mesmo ponteiro e se referem ao mesmo ponteiro), atribui desired em *p utilizando a memória ordenar restrições especificadas pelo success e retorna true. Se elas não são equivalentes, atribui *p *expected em utilizar a memória ordenação restrições especificadas por failure e retorna 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)
      Mesmo que 10), mas pode falhar spuriously.
      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.
      Todas essas funções chamar comportamento indefinido se p é um ponteiro nulo.
      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.

      Parâmetros

      p, expected -
      um ponteiro para uma 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 -
      memória ordenação seletores de std::memory_order tipo
      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.

      Exceções

      Estas funções não lançar exceções.
      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.

      Voltar

      1)
      true se o acesso atômico é implementado usando sem bloqueio instruções
      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 @ A cópia do ponteiro apontado para compartilhada.
      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.
      @ @ Nada 4,5
      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 @ A cópia do ponteiro anteriormente apontado para compartilhado
      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 se os ponteiros compartilhados são equivalentes e que a troca foi realizada, false outra forma.
      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.

      Veja também

      (C++11)
      verifica se as operações do tipo atômico são lock-livre
      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.

      (modelo de função) [edit]
      (C++11)
      (C++11)
      atomicamente substitui o valor do objeto atômico com um argumento não-atômica
      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.

      (modelo de função) [edit]
      (C++11)
      (C++11)
      atomicamente obtém o valor armazenado em um objeto atómico
      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.

      (modelo de função) [edit]
      (C++11)
      (C++11)
      atomicamente substitui o valor do objeto atômico com não atômica argumento e retorna o valor antigo do atômica
      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.

      (modelo de função) [edit]
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      atomicamente compara o valor do objeto atômico com não atômica argumento e realiza troca atômica se carga igual ou atômica se não
      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.

      (modelo de função) [edit]