Espaços nominais
Variantes
Acçõ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>

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

 
 
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
initializer_list(C++11)
bitset
hash(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.
pair
tuple(C++11)
piecewise_construct_t(C++11)
piecewise_construct(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.
swap
forward(C++11)
move(C++11)
move_if_noexcept(C++11)
declval(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.
allocator
allocator_traits(C++11)
allocator_arg_t(C++11)
allocator_arg(C++11)
uses_allocator(C++11)
scoped_allocator_adaptor(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.
uninitialized_copy
uninitialized_copy_n(C++11)
uninitialized_fill
uninitialized_fill_n
raw_storage_iterator
get_temporary_buffer
return_temporary_buffer
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.
unique_ptr(C++11)
shared_ptr(C++11)
weak_ptr(C++11)
auto_ptr(obsoleta)
owner_less(C++11)
enable_shared_from_this(C++11)
bad_weak_ptr(C++11)
default_delete(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.
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)
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.
pointer_traits(C++11)
addressof(C++11)
align(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.
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) (a partir do C++ 11)
template< class T >
std::shared_ptr<T> atomic_load( const std::shared_ptr<T>* p );
(2) (a partir do C++ 11)
template< class T >

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

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

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

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

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

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

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

                                    std::shared_ptr<T> r);
(6) (a partir do 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) (a partir do 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) (a partir do 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) (a partir do 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) (a partir do 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) (a partir do 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.

Índice

[editar] 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.

[editar] 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.

[editar] 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.

[editar] Veja também

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]
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]
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]
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]
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]