Standard library header <memory>
From cppreference.com
This header is part of the dynamic memory management library.
Contents |
[edit] Classes
Smart pointers categories |
|
(C++11)
|
smart pointer with unique object ownership semantics (class template) |
(C++11)
|
smart pointer with shared object ownership semantics (class template) |
(C++11)
|
weak reference to an object managed by std::shared_ptr (class template) |
(deprecated)
|
smart pointer with strict object ownership semantics (class template) |
Smart pointers helper classes |
|
(C++11)
|
provides mixed-type owner-based ordering of shared and weak pointers (class template) |
(C++11)
|
allows an object to create a shared_ptr referring to itself (class template) |
(C++11)
|
exception thrown when accessing a weak_ptr which refers to already destroyed object (class) |
(C++11)
|
default deleter for unique_ptr (class template) |
Allocators |
|
the default allocator (class template) |
|
(C++11)
|
provides information about allocator types (class template) |
(C++11)
|
tag type used to select allocator-aware constructor overloads (class) |
(C++11)
|
an object of type std::allocator_arg_t used to select allocator-aware constructors (constant) |
(C++11)
|
checks if the specified type supports uses-allocator construction (class template) |
Other |
|
(C++11)
|
lists pointer safety models (class) |
(C++11)
|
provides information about pointer-like types (class template) |
(C++11)
|
hash support for std::shared_ptr (class template specialization) |
(C++11)
|
hash support for std::unique_ptr (class template specialization) |
Forward declaration |
|
Defined in header
<functional> |
|
(C++11)
|
hash function object (class template) |
Constants |
|
(C++11)
|
an object of type std::allocator_arg_t used to select allocator-aware constructors (constant) |
[edit] Functions
Uninitialized storage |
|
copies a range of objects to an uninitialized area of memory (function template) |
|
(C++11)
|
copies a number of objects to an uninitialized area of memory (function template) |
copies an object to an uninitialized area of memory (function template) |
|
copies an object to an uninitialized area of memory (function template) |
|
an iterator that allows standard algorithms to store results in uninitialized memory (class template) |
|
obtains uninitialized storage (function template) |
|
frees uninitialized storage (function template) |
|
Garbage collector support |
|
(C++11)
|
declares that an object can not be recycled (function) |
(C++11)
|
declares that an object can be recycled (function template) |
(C++11)
|
declares that a memory area does not contain traceable pointers (function) |
(C++11)
|
cancels the effect of std::declare_no_pointers (function) |
(C++11)
|
returns the current pointer safety model (function) |
Miscellaneous |
|
(C++11)
|
obtains actual address of an object, even if the & operator is overloaded (function template) |
(C++11)
|
aligns a pointer in a buffer (function) |
Smart pointer non-member operations |
|
creates a shared pointer that manages a new object (function template) |
|
creates a shared pointer that manages a new object allocated using an allocator (function template) |
|
applies static_cast, dynamic_cast or const_cast to the type of the managed object (function template) |
|
returns the deleter of specified type, if owned (function template) |
|
compares with another shared_ptr or with nullptr (function template) |
|
outputs the value of the managed pointer to an output stream (function template) |
|
(C++11)
|
specializes the std::swap algorithm (function template) |
specializes atomic operations (function template) |
compares to another unique_ptr or with nullptr (function template) |
|
(C++11)
|
specializes the std::swap algorithm (function template) |
(C++11)
|
specializes the std::swap algorithm (function template) |
Allocator non-member operations |
|
compares two allocator instances (public member function of std::allocator )
|
|
compares two scoped_allocator_adaptor instances (public member function of std::scoped_allocator_adaptor )
|
[edit] Synopsis
namespace std { // pointer traits template <class Ptr> struct pointer_traits; template <class T> struct pointer_traits<T*>; // pointer safety enum class pointer_safety { relaxed, preferred, strict }; void declare_reachable(void *p); template <class T> T *undeclare_reachable(T *p); void declare_no_pointers(char *p, size_t n); void undeclare_no_pointers(char *p, size_t n); pointer_safety get_pointer_safety() noexcept; // pointer alignment function void *align(std::size_t alignment, std::size_t size, void *&ptr, std::size_t& space); // allocator argument tag struct allocator_arg_t { }; constexpr allocator_arg_t allocator_arg = allocator_arg_t(); // uses_allocator template <class T, class Alloc> struct uses_allocator; // allocator traits template <class Alloc> struct allocator_traits; // the default allocator: template <class T> class allocator; template <> class allocator<void>; template <class T, class U> bool operator==(const allocator<T>&, const allocator<U>&) noexcept; template <class T, class U> bool operator!=(const allocator<T>&, const allocator<U>&) noexcept; // raw storage iterator: template <class OutputIterator, class T> class raw_storage_iterator; // temporary buffers: template <class T> pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept; template <class T> void return_temporary_buffer(T* p); // specialized algorithms: template <class T> T* addressof(T& r) noexcept; template <class InputIterator, class ForwardIterator> ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result); template <class InputIterator, class Size, class ForwardIterator> ForwardIterator uninitialized_copy_n(InputIterator first, Size n, ForwardIterator result); template <class ForwardIterator, class T> void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x); template <class ForwardIterator, class Size, class T> ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T& x); // class template unique_ptr: template <class T> class default_delete; template <class T> class default_delete<T[]>; template <class T, class D = default_delete<T>> class unique_ptr; template <class T, class D> class unique_ptr<T[], D>; template <class T1, class D1, class T2, class D2> bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); template <class T1, class D1, class T2, class D2> bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); template <class T1, class D1, class T2, class D2> bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); template <class T1, class D1, class T2, class D2> bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); template <class T1, class D1, class T2, class D2> bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); template <class T1, class D1, class T2, class D2> bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); template <class T, class D> bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept; template <class T, class D> bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept; template <class T, class D> bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept; template <class T, class D> bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept; template <class T, class D> bool operator<(const unique_ptr<T, D>& x, nullptr_t); template <class T, class D> bool operator<(nullptr_t, const unique_ptr<T, D>& y); template <class T, class D> bool operator<=(const unique_ptr<T, D>& x, nullptr_t); template <class T, class D> bool operator<=(nullptr_t, const unique_ptr<T, D>& y); template <class T, class D> bool operator>(const unique_ptr<T, D>& x, nullptr_t); template <class T, class D> bool operator>(nullptr_t, const unique_ptr<T, D>& y); template <class T, class D> bool operator>=(const unique_ptr<T, D>& x, nullptr_t); template <class T, class D> bool operator>=(nullptr_t, const unique_ptr<T, D>& y); // class bad_weak_ptr: class bad_weak_ptr; // class template shared_ptr: template<class T> class shared_ptr; // shared_ptr comparisons: template<class T, class U> bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; template<class T, class U> bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; template<class T, class U> bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; template<class T, class U> bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; template<class T, class U> bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; template<class T, class U> bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; template <class T> bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept; template <class T> bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept; template <class T> bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept; template <class T> bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept; template <class T> bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept; template <class T> bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept; template <class T> bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept; template <class T> bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept; template <class T> bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept; template <class T> bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept; template <class T> bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept; template <class T> bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept; // shared_ptr specialized algorithms: template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept; // shared_ptr casts: template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const& r) noexcept; template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const& r) noexcept; template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const& r) noexcept; // shared_ptr get_deleter: template<class D, class T> D* get_deleter(shared_ptr<T> const& p) noexcept; // shared_ptr I/O: template<class E, class T, class Y> basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, shared_ptr<Y> const& p); // class template weak_ptr: template<class T> class weak_ptr; // weak_ptr specialized algorithms: template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept; // class template owner_less: template<class T> class owner_less; // class template enable_shared_from_this: template<class T> class enable_shared_from_this; // shared_ptr atomic access: template<class T> bool atomic_is_lock_free(const shared_ptr<T>* p); template<class T> shared_ptr<T> atomic_load(const shared_ptr<T>* p); template<class T> shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo); template<class T> void atomic_store(shared_ptr<T>* p, shared_ptr<T> r); template<class T> void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo); template<class T> shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r); template<class T> shared_ptr<T> atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo); template<class T> bool atomic_compare_exchange_weak( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w); template<class T> bool atomic_compare_exchange_strong( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w); template<class T> bool atomic_compare_exchange_weak_explicit( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w, memory_order success, memory_order failure); template<class T> bool atomic_compare_exchange_strong_explicit( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w, memory_order success, memory_order failure); // hash support template <class T> struct hash; template <class T, class D> struct hash<unique_ptr<T, D> >; template <class T> struct hash<shared_ptr<T> >; // auto_ptr (deprecated) template <class X> class auto_ptr; }
This section is incomplete Reason: Class synopses |