template< class Y > operator auto_ptr_ref<Y>(); (1) (deprecated) template< class Y > operator auto_ptr<Y>(); (2) (deprecated) 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 convertible and assignable from this template. The implementation is allowed to provide the template with a different name or implement equivalent functionality in other ways. 2) Construc

T* get() const; (deprecated) Returns the pointer that is held by *this. Parameters (none). Return value The pointer held by *this. Exceptions (none). See also operator*operator-> accesses the managed object (public member function)

explicit auto_ptr( X* p = 0 ); (1) (deprecated) auto_ptr( auto_ptr& r ); (2) (deprecated) template< class Y > auto_ptr( auto_ptr<Y>& r ); (3) (deprecated) template< class Y > auto_ptr( auto_ptr_ref<Y> m ); (4) (deprecated) Constructs the auto_ptr from a pointer that refers to the object to manage. 1) Constructs the auto_ptr with pointer p. 2) Constructs the auto_ptr with the pointer held in r. r.release() is called to acquire the owner

Defined in header <memory> template< class T > class auto_ptr; (1) (until C++17) (deprecated since C++11) template<> class auto_ptr<void>; (2) (until C++17) (deprecated since C++11) 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 used to provide exception safety for dynamically-allocated objects, for passing ownership of dynamically-allocated objects i

Defined in header <cstdlib> extern "C" int at_quick_exit( void (*func)() ); extern "C++" int at_quick_exit( void (*func)() ); (since C++11) Registers the function pointed to by func to be called on quick program termination (via std::quick_exit). Calling the function from several threads does not induce a data race. The implementation shall support the registration of at least 32 functions. The registered functions will not be called on normal program termination. If a fu

Defined in header <atomic> extern "C" void atomic_thread_fence( std::memory_order order ); (since C++11) Establishes memory synchronization ordering of non-atomic and relaxed atomic accesses, as instructed by order, without an associated atomic operation. For example, all non-atomic and relaxed atomic stores that happen before a std::memory_order_release fence in thread A will be synchronized with non-atomic and relaxed atomic loads from the same locations made in thread B

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

Defined in header <atomic> extern "C" void atomic_signal_fence( std::memory_order order ); (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 ordering are issued. Only reordering of the instructions by the compiler is suppressed as order instructs. Fo

Defined in header <atomic> (1) (since C++11) template< class T > T atomic_load( const std::atomic<T>* obj ); template< class T > T atomic_load( const volatile std::atomic<T>* obj ); (2) (since C++11) template< class T > T atomic_load_explicit( const std::atomic<T>* obj, std::memory_order order ); template< class T > T atomic_load_explicit( const volatile std::atomic<T>* obj,

Defined in header <atomic> (1) (since C++11) template< class T > bool atomic_is_lock_free( const volatile std::atomic<T>* obj ); template< class T > bool atomic_is_lock_free( const std::atomic<T>* obj ); #define ATOMIC_BOOL_LOCK_FREE /* unspecified */ #define ATOMIC_CHAR_LOCK_FREE /* unspecified */ #define ATOMIC_CHAR16_T_LOCK_FREE /* unspecified */ #define ATOMIC_CHAR32_T_LOCK_FREE /* unspecified */ #define ATOMIC_WCHAR_T_LOCK_FREE /*