Smart pointers enable automatic, exception-safe, object lifetime management.
Defined in header <memory> |
|
|---|---|
Pointer 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) |
|
(removed in C++17) | smart pointer with strict object ownership semantics (class template) |
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 are class templates encapsulating memory allocation strategy. This allows generic containers to decouple memory management from the data itself.
Defined in header <memory> |
|
|---|---|
| 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) |
|
(C++20) | prepares the argument list matching the flavor of uses-allocator construction required by the given type (function template) |
|
(C++20) | creates an object of the given type by means of uses-allocator construction (function template) |
|
(C++20) | creates an object of the given type at specified memory location by means of uses-allocator construction (function template) |
Defined in header <scoped_allocator> |
|
|
(C++11) | implements multi-level allocator for multi-level containers (class template) |
Defined in header <memory_resource> |
|
Defined in namespace pmr |
|
|
(C++17) | an allocator that supports run-time polymorphism based on the std::memory_resource it is constructed with (class template) |
Memory resources implement memory allocation strategies that can be used by std::pmr::polymorphic_allocator.
Defined in header <memory_resource> |
|
|---|---|
Defined in namespace pmr |
|
|
(C++17) | an abstract interface for classes that encapsulate memory resources (class) |
|
(C++17) | returns a static program-wide std::pmr::memory_resource that uses the global operator new and operator delete to allocate and deallocate memory (function) |
|
(C++17) | returns a static std::pmr::memory_resource that performs no allocation (function) |
|
(C++17) | gets the default std::pmr::memory_resource (function) |
|
(C++17) | sets the default std::pmr::memory_resource (function) |
|
(C++17) | a set of constructor options for pool resources (class) |
|
(C++17) | a thread-safe std::pmr::memory_resource for managing allocations in pools of different block sizes (class) |
|
(C++17) | a thread-unsafe std::pmr::memory_resource for managing allocations in pools of different block sizes (class) |
|
(C++17) | a special-purpose std::pmr::memory_resource that releases the allocated memory only when the resource is destroyed (class) |
Several utilities are provided to create and access raw storage.
Defined in header <memory> |
|
|---|---|
| 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, defined by a range (function template) |
|
| copies an object to an uninitialized area of memory, defined by a start and a count (function template) |
|
|
(C++17) | moves a range of objects to an uninitialized area of memory (function template) |
|
(C++17) | moves a number of objects to an uninitialized area of memory (function template) |
|
(C++17) | constructs objects by default-initialization in an uninitialized area of memory, defined by a range (function template) |
|
(C++17) | constructs objects by default-initialization in an uninitialized area of memory, defined by a start and a count (function template) |
|
(C++17) | constructs objects by value-initialization in an uninitialized area of memory, defined by a range (function template) |
|
(C++17) | constructs objects by value-initialization in an uninitialized area of memory, defined by a start and a count (function template) |
|
(C++17) | destroys an object at a given address (function template) |
|
(C++17) | destroys a range of objects (function template) |
|
(C++17) | destroys a number of objects in a range (function template) |
|
(deprecated in C++17)(removed in C++20) | an iterator that allows standard algorithms to store results in uninitialized memory (class template) |
|
(deprecated in C++17)(removed in C++20) | obtains uninitialized storage (function template) |
|
(deprecated in C++17)(removed in C++20) | frees uninitialized storage (function template) |
C++20 provides constrained uninitialized memory algorithms that accept range arguments or iterator-sentinel pairs.
Defined in header <memory> |
|
|---|---|
Defined in namespace std::ranges |
|
|
(C++20) | copies a range of objects to an uninitialized area of memory (niebloid) |
|
(C++20) | copies a number of objects to an uninitialized area of memory (niebloid) |
|
(C++20) | copies an object to an uninitialized area of memory, defined by a range (niebloid) |
|
(C++20) | copies an object to an uninitialized area of memory, defined by a start and a count (niebloid) |
|
(C++20) | moves a range of objects to an uninitialized area of memory (niebloid) |
|
(C++20) | moves a number of objects to an uninitialized area of memory (niebloid) |
|
(C++20) | constructs objects by default-initialization in an uninitialized area of memory, defined by a range (niebloid) |
|
(C++20) | constructs objects by default-initialization in an uninitialized area of memory, defined by a start and count (niebloid) |
|
(C++20) | constructs objects by value-initialization in an uninitialized area of memory, defined by a range (niebloid) |
|
(C++20) | constructs objects by value-initialization in an uninitialized area of memory, defined by a start and a count (niebloid) |
|
(C++20) | destroys an object at a given address (niebloid) |
|
(C++20) | destroys a range of objects (niebloid) |
|
(C++20) | destroys a number of objects in a range (niebloid) |
Defined in header <memory> |
|
|---|---|
|
(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) | lists pointer safety models (enum) |
|
(C++11) | returns the current pointer safety model (function) |
Defined in header <memory> |
|
|---|---|
|
(C++11) | provides information about pointer-like types (class template) |
|
(C++20) | obtains a raw pointer from a pointer-like type (function template) |
|
(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) |
|
(C++20) | informs the compiler that a pointer is aligned (function template) |
Includes e.g. std::malloc, std::free.
Includes e.g. operator new , operator delete , std::set_new_handler.
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/memory