Linux Manuals session 3

std::back_insert_iterator – std::back_insert_iterator Synopsis Defined in header<iterator> template <class Container> class back_insert_iterator : public std::iterator<std::output_iterator_tag, (until C++ 17) void, void, void, void> template <class Container> (since C++ 17) class back_insert_iterator; std::back_insert_iterator is an LegacyOutputIterator that appends to a container for which it was constructed. The container’s push_back() member function is called whenever the iterator (whether…

std::auto_ptr_ref< _Tp1 > – Synopsis Public Member Functions auto_ptr_ref (_Tp1 *__p) Public Attributes _Tp1 * _M_ptr Detailed Description template<typename _Tp1>struct std::auto_ptr_ref< _Tp1 > A wrapper class to provide auto_ptr with reference semantics. For example, an auto_ptr can be assigned (or constructed from) the result of a function which returns an auto_ptr by value. All the…

std::auto_ptr<T>::reset – std::auto_ptr<T>::reset Synopsis void reset(T *p = 0) throw(); (deprecated in C++ 11)(removed in C++ 17) Replaces the held pointer by p. If the currently held pointer is not null pointer, delete get() is called. Parameters p – a pointer to an object to manage Return value (none) See also         releases ownership of the…

std::auto_ptr<T>::release – std::auto_ptr<T>::release Synopsis T* release() throw(); (deprecated in C++11)                        (removed in C++17) Releases the held pointer. After the call *this holds the null pointer. Parameters (none) Return value get(). See also       destroys the managed object reset (public member function)

std::auto_ptr<T>::operatorauto_ptr<Y> – std::auto_ptr<T>::operatorauto_ptr<Y> Synopsis template< class Y > (1) (deprecated in C++11) operator auto_ptr_ref<Y>() throw(); (removed in C++17) template< class Y > (2) (deprecated in C++11) operator auto_ptr<Y>() throw(); (removed in C++17) Converts *this to an auto_ptr for a different type Y. 1) Returns an implementation-defined type that holds a reference to *this. std::auto_ptr is…

std::auto_ptr<T>::operator= – std::auto_ptr<T>::operator= Synopsis auto_ptr& operator=( auto_ptr& r ) throw(); (1) (deprecated in C++11) (removed in C++17) template< class Y > (2) (deprecated in C++11) auto_ptr& operator=( auto_ptr<Y>& r ) throw(); (removed in C++17) auto_ptr& operator=( auto_ptr_ref m ) throw(); (3) (deprecated in C++11) (removed in C++17) Replaces the managed object with the one managed…

std::auto_ptr<T>::operator*,std::auto_ptr<T>::operator-> – std::auto_ptr<T>::operator*,std::auto_ptr<T>::operator-> Synopsis T& operator*() const throw(); (1) (deprecated in C++11)                                    (removed in C++17) T* operator->() const throw(); (2) (deprecated in C++11)                                    (removed in C++17) Dereferences a pointer to the managed object. The first version requires get() != 0. Parameters (none) Return value 1) *get(). 2) get(). See also     returns a pointer to the…

std::auto_ptr<T>::get – std::auto_ptr<T>::get Synopsis T* get() const throw(); (deprecated in C++11)                          (removed in C++17) Returns the pointer that is held by *this. Parameters (none) Return value The pointer held by *this. See also            accesses the managed object operator* (public member function) operator->

std::auto_ptr<T>::~auto_ptr – std::auto_ptr<T>::~auto_ptr Synopsis ~auto_ptr() throw(); (deprecated in C++11)                       (removed in C++17) Destroys the managed object. Calls delete get().

std::auto_ptr – std::auto_ptr Synopsis Defined in header <memory> template< class T > class auto_ptr; (1) (deprecated in C++11)                                         (removed in C++17) template<> class auto_ptr<void>; (2) (deprecated in C++11)                                         (removed in C++17) auto_ptr is a smart pointer that manages an object obtained via new_expression and deletes that object when auto_ptr itself is destroyed. It may be…

std::atomic_thread_fence – std::atomic_thread_fence Synopsis Defined in header <atomic> extern "C" void atomic_thread_fence( std::memory_order order ) noexcept; (since C++11) Establishes memory_synchronization_ordering of non-atomic and relaxed atomic accesses, as instructed by order, without an associated atomic operation. Fence-atomic synchronization A release fence F in thread A synchronizes-with atomic acquire_operation Y in thread B, if * there exists…

std::atomic_store,std::atomic_store_explicit – std::atomic_store,std::atomic_store_explicit Synopsis Defined in header<atomic> template <class T> void atomic_store(std::atomic<T> *obj, typename std::atomic<T>::value_type desr) noexcept; template <class T> void atomic_store(volatile std::atomic<T> *obj, typename std::atomic<T>::value_type desr) noexcept; template <class T> (1)(since C++ 11) void atomic_store_explicit(std::atomic<T> *obj, typename std::atomic<T>::value_type desr, std::memory_order order) noexcept; (2)(since C++ 11) template <class T> void atomic_store_explicit(volatile std::atomic<T> *obj, typename std::atomic<T>::value_type…

std::atomic_signal_fence – std::atomic_signal_fence Synopsis Defined in header <atomic> extern "C" void atomic_signal_fence( std::memory_order order ) noexcept; (since C++11) Establishes memory synchronization ordering of non-atomic and relaxed atomic accesses, as instructed by order, between a thread and a signal handler executed on the same thread. This is equivalent to std::atomic_thread_fence, except no CPU instructions for memory…

std::atomic_ref<T>::store – std::atomic_ref<T>::store Synopsis void store(T desired, std::memory_order order = std::memory_order_seq_cst) const noexcept; (since C++ 20) Atomically replaces the current value of the referenced object with desired. Memory is affected according to the value of order. order must be one of std::memory_order_relaxed, std::memory_order_release or std::memory_order_seq_cst. Otherwise the behavior is undefined. Parameters desired – the value…

std::atomic_ref<T>::required_alignment – std::atomic_ref<T>::required_alignment Synopsis static constexpr std::size_t required_alignment= /*implementation-defined*/; (since C++20) The value of required_alignment is the required alignment for an object to be referenced by an atomic reference, which is at least alignof(T). Notes Hardware could require that an object to be referenced by an atomic_ref<T> have stricter alignment than other T objects, and…

std::atomic_ref<T>::operatorT – std::atomic_ref<T>::operatorT Synopsis operator T() const noexcept; (since C++20) Atomically loads and returns the current value of the referenced object. Equivalent to load(). Parameters (none) Return value The current value of the referenced object. See also      atomically obtains the value of the referenced object load (public member function)

std::atomic_ref<T>::operator= – std::atomic_ref<T>::operator= Synopsis T operator=(T desired) const noexcept; (1) atomic_ref & operator=(const atomic_ref &) = delete; (2) 1) Atomically assigns a value desired to the referenced object. Equivalent to store(desired). 2) atomic_ref is not CopyAssignable. Parameters desired – value to assign Return value desired. Notes Unlike most assignment operators, the assignment operator for atomic_ref…

std::atomic_ref<T>::operator++,++(int),–,–(int) – std::atomic_ref<T>::operator++,++(int),–,–(int) Synopsis member only of atomic_ref<Integral> and atomic_ref<T*> template specializations value_type operator++() const noexcept; (1) (since C++20) value_type operator++(int) const noexcept; (2) (since C++20) value_type operator–() const noexcept; (3) (since C++20) value_type operator–(int) const noexcept; (4) (since C++20) Atomically increments or decrements the current value of the referenced object. These operations are read-modify-write…

std::atomic_ref<T>::load – std::atomic_ref<T>::load Synopsis T load(std::memory_order order = std::memory_order_seq_cst) const noexcept; (since C++ 20) Atomically loads and returns the current value of the referenced object. Memory is affected according to the value of order. order must be one of std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire or std::memory_order_seq_cst. Otherwise the behavior is undefined. Parameters order – memory order constraints…

std::atomic_ref<T>::is_lock_free – std::atomic_ref<T>::is_lock_free Synopsis bool is_lock_free() const noexcept; (since C++20) Checks whether the atomic operations on this object are lock-free. Parameters (none) Return value true if the atomic operations on this object are lock-free, false otherwise. Notes All atomic types except for std::atomic_flag may be implemented using mutexes or other locking operations, rather than using…