Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::atomic<T>::fetch_add

      From cppreference.com
      <cpp‎ |atomic‎ |atomic
       
       
      Concurrency support library
      Threads
      (C++11)
      (C++20)
      this_thread namespace
      (C++11)
      (C++11)
      (C++11)
      Cooperative cancellation
      Mutual exclusion
      Generic lock management
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      Condition variables
      (C++11)
      Semaphores
      Latches and Barriers
      (C++20)
      (C++20)
      Futures
      (C++11)
      (C++11)
      (C++11)
      Safe reclamation
      Hazard pointers
      Atomic types
      (C++11)
      (C++20)
      Initialization of atomic types
      (C++11)(deprecated in C++20)
      (C++11)(deprecated in C++20)
      Memory ordering
      (C++11)(deprecated in C++26)
      Free functions for atomic operations
      Free functions for atomic flags
       
       
      member only ofatomic<Integral > specializations
      andatomic<Floating > specializations(since C++20)
      T fetch_add( T arg,std::memory_order order=
                             std::memory_order_seq_cst)noexcept;
      (1)(since C++11)
      T fetch_add( T arg,std::memory_order order=
                             std::memory_order_seq_cst)volatilenoexcept;
      (2)(since C++11)
      member only ofatomic<T*> partial specialization
      T* fetch_add(std::ptrdiff_t arg,

                   std::memory_order order=

                       std::memory_order_seq_cst)noexcept;
      (3)(since C++11)
      T* fetch_add(std::ptrdiff_t arg,

                   std::memory_order order=

                       std::memory_order_seq_cst)volatilenoexcept;
      (4)(since C++11)

      Atomically replaces the current value with the result of arithmetic addition of the value andarg. That is, it performs atomic post-increment. The operation is a read-modify-write operation. Memory is affected according to the value oforder.

      1,2) For signed integral types, arithmetic is defined to use two’s complement representation. There are no undefined results.

      For floating-point types, thefloating-point environment in effect may be different from the calling thread's floating-point environment. The operation need not conform to the correspondingstd::numeric_limits traits but is encouraged to do so. If the result is not a representable value for its type, the result is unspecified but the operation otherwise has no undefined behavior.

      (since C++20)
      3,4) The result may be an undefined address, but the operation otherwise has no undefined behavior.
      IfT is not a complete object type, the program is ill-formed.


      It is deprecated ifstd::atomic<T>::is_always_lock_free isfalse and overload(2) or(4) participates in overload resolution.

      (since C++20)

      Contents

      [edit]Parameters

      arg - the other argument of arithmetic addition
      order - memory order constraints to enforce

      [edit]Return value

      The value immediately preceding the effects of this function in themodification order of*this.

      [edit]Example

      Run this code
      #include <array>#include <atomic>#include <iostream>#include <thread> std::atomic<longlong> data{10};std::array<longlong,5> return_values{}; void do_work(int thread_num){longlong val= data.fetch_add(1,std::memory_order_relaxed);    return_values[thread_num]= val;} int main(){{std::jthread th0{do_work,0};std::jthread th1{do_work,1};std::jthread th2{do_work,2};std::jthread th3{do_work,3};std::jthread th4{do_work,4};} std::cout<<"Result : "<< data<<'\n'; for(longlong val: return_values)std::cout<<"Seen return value : "<< val<<std::endl;}

      Possible output:

      Result : 15Seen return value : 11Seen return value : 10Seen return value : 14Seen return value : 12Seen return value : 13

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      P0558R1C++11arithmetic permitted on pointers to (possibly cv-qualified)void or functionmade ill-formed

      [edit]See also

      adds a non-atomic value to an atomic object and obtains the previous value of the atomic
      (function template)[edit]
      increments or decrements the atomic value by one
      (public member function)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/atomic/atomic/fetch_add&oldid=161349"

      [8]ページ先頭

      ©2009-2025 Movatter.jp