Espaços nominais
Variantes
    Ações

      std::atomic_compare_exchange_weak, std::atomic_compare_exchange_strong, std::atomic_compare_exchange_weak_explicit, std::atomic_compare_exchange_strong_explicit

      De cppreference.com

      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 operações atômica
      Tipos
      Original:
      Types
      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)
      Funções
      Original:
      Functions
      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)
      (C++11)(C++11)(C++11)(C++11)
      (C++11)(C++11)
      (C++11)(C++11)
      (C++11)(C++11)
      (C++11)(C++11)
      (C++11)(C++11)
      Bandeiras atômicas
      Original:
      Atomic flags
      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)
      Inicialização
      Original:
      Initialization
      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)
      Memória de encomenda
      Original:
      Memory ordering
      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)
       
      <tbody> </tbody>
      Definido no cabeçalho <atomic>
      template< class T > bool atomic_compare_exchange_weak( std::atomic<T>* obj, T* expected, T desired ); template< class T > bool atomic_compare_exchange_weak( volatile std::atomic<T>* obj, T* expected, T desired );
      		 (1) (desde C++11)
      template< class T > bool atomic_compare_exchange_strong( std::atomic<T>* obj, T* expected, T desired ); template< class T > bool atomic_compare_exchange_strong( volatile std::atomic<T>* obj, T* expected, T desired );
      		 (2) (desde C++11)
      template< class T > bool atomic_compare_exchange_weak_explicit( std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail ); template< class T > bool atomic_compare_exchange_weak_explicit( volatile std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail );
      		 (3) (desde C++11)
      template< class T > bool atomic_compare_exchange_strong_explicit( std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail ); template< class T > bool atomic_compare_exchange_strong_explicit( volatile std::atomic<T>* obj, T* expected, T desired, std::memory_order succ, std::memory_order fail );
      		 (4) (desde C++11)
      Atomicamente compara o valor apontado por obj com o valor apontado por expected, e se estas forem iguais, substitui o ex-desired (executa ler-modificar-escrever a operação). Caso contrário, carrega o valor real apontado por obj em *expected (executa a operação de carga).
      Original:
      Atomically compares the value pointed to by obj with the value pointed to by expected, and if those are equal, replaces the former with desired (performs read-modify-write operation). Otherwise, loads the actual value pointed to by obj into *expected (performs load operation).
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      Os modelos de memória para a leitura-modificação-gravação e operações de carga são succ e fail respectivamente. As versões (1-2) usar std::memory_order_seq_cst por padrão.
      Original:
      The memory models for the read-modify-write and load operations are succ and fail respectively. The (1-2) versions use std::memory_order_seq_cst by default.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      As formas fracas ((1) e (3)) das funções podem falhar spuriously, isto é, actuar como se *obj != *expected mesmo se eles forem iguais. Quando uma comparação e troca-se em um loop, a versão fraca trará melhor desempenho em algumas plataformas. Quando um fraco comparar-e-troca exigiria um laço e um forte não, o forte é preferível.
      Original:
      The weak forms ((1) and (3)) of the functions are allowed to fail spuriously, that is, act as if *obj != *expected even if they are equal. When a compare-and-exchange is in a loop, the weak version will yield better performance on some platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the strong one is preferable.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      Essas funções são definidas em termos de funções de membro de std::atomic:
      Original:
      These functions are defined in terms of member functions of std::atomic:
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      1) obj->compare_exchange_weak(exp, desr)
      2) obj->compare_exchange_strong(exp, desr)
      3) obj->compare_exchange_weak(exp, desr, succ, fail)
      4) obj->compare_exchange_strong(exp, desr, succ, fail)

      Parâmetros

      obj -
      ponteiro para o objeto atômico para testar e modificar
      Original:
      pointer to the atomic object to test and modify
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      expected -
      ponteiro para o valor esperado para ser encontrado no objeto atómica
      Original:
      pointer to the value expected to be found in the atomic object
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      desired -
      o valor para armazenar no objeto atômico se for como o esperado
      Original:
      the value to store in the atomic object if it is as expected
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      succ -
      o sycnhronization memória de ordenação para a leitura-modificação-gravação operação, se a comparação for bem-sucedido. Todos os valores são permitidos .
      Original:
      the memory sycnhronization ordering for the read-modify-write operation if the comparison succeeds. All values are permitted.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      fail -
      o sycnhronization memória de ordenação para a operação de carga se a comparação falhar. Não pode ser std::memory_order_release ou std::memory_order_ack_rel e não pode especificar mais forte do que succ ordenação
      Original:
      the memory sycnhronization ordering for the load operation if the comparison fails. Cannot be std::memory_order_release or std::memory_order_ack_rel and cannot specify stronger ordering than succ
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      Valor de retorno

      O resultado da comparação: true se *obj foi igual a *exp, false contrário.
      Original:
      The result of the comparison: true if *obj was equal to *exp, false otherwise.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      Exceções

      noexcept specification:  
      <tbody> </tbody>
      noexcept
        (desde C++11)

      Exemplo

      Este exemplo mostra como comparar-e-troca pode ser usado para implementar sem bloqueio de acrescentar a uma lista vinculada isoladamente
      Original:
      This example shows how compare-and-exchange may be used to implement lock-free append to a singly linked list
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      void append(list* s, node* n)
{
    node* head;
    do {
        head = s->head;
        n->next = head;
    } while(! std::atomic_compare_exchange_weak(s->head, head, n));
}


      Veja também
      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.

      (of std::atomic função pública membro) [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]
      especializada operações atômicas para std :: shared_ptr
      Original:
      specializes atomic operations for 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.

      (modelo de função)
      Documentação C para atomic_compare_exchange, atomic_compare_exchange_explicit