W3cubDocs

/C++

Dynamic memory management

Smart pointers

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)
(deprecated in C++11)(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)
Smart pointer adaptors
(C++23)
interoperates with foreign pointer setters and resets a smart pointer on destruction
(class template)
(C++23)
creates an out_ptr_t with an associated smart pointer and resetting arguments
(function template)
(C++23)
interoperates with foreign pointer setters, obtains the initial pointer value from a smart pointer, and resets it on destruction
(class template)
(C++23)
creates an inout_ptr_t with an associated smart pointer and resetting arguments
(function template)

Allocators

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++23)
records the address and the actual size of storage allocated by allocate_at_least
(class template)
(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 std::pmr
(C++17)
an allocator that supports run-time polymorphism based on the std::pmr::memory_resource it is constructed with
(class template)

Memory resources (since C++17)

Memory resources implement memory allocation strategies that can be used by std::pmr::polymorphic_allocator.

Defined in header <memory_resource>
Defined in namespace std::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)

Uninitialized storage

Several utilities are provided to create and access raw storage.

Defined in header <memory>
(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)

Uninitialized memory algorithms

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)
(C++20)
creates an object at a given address
(function template)

Constrained uninitialized memory algorithms (since C++20)

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)
specifies some operations on iterators, sentinels and ranges are non-throwing
(exposition-only concept)
(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)
(C++20)
creates an object at a given address
(niebloid)

Garbage collector support (until C++23)

Defined in header <memory>
(C++11)(removed in C++23)
declares that an object can not be recycled
(function)
(C++11)(removed in C++23)
declares that an object can be recycled
(function template)
(C++11)(removed in C++23)
declares that a memory area does not contain traceable pointers
(function)
(C++11)(removed in C++23)
cancels the effect of std::declare_no_pointers
(function)
(C++11)(removed in C++23)
lists pointer safety models
(enum)
(C++11)(removed in C++23)
returns the current pointer safety model
(function)

Explicit lifetime management (since C++23)

Defined in header <memory>
(C++23)
implicitly creates objects in given storage with the object representation reused
(function template)

Miscellaneous

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)

Low level memory management

Includes e.g. operator new, operator delete, std::set_new_handler.

Defined in header <new>

C-style memory management

Includes e.g. std::malloc, std::free.

Defined in header <cstdlib>

Explicit lifetime management (since C++23)

Defined in header <memory>
(C++23)
implicitly creates objects in given storage with the object representation reused
(function template)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/memory