All Smart Pointers and Ownership Types

All Smart Pointers and Ownership Types

A compact index of ownership, observing, and lifetime-adjacent utility types in modern C++.

How to use this reference page

Use reference pages to confirm names, categories, nearby facilities, and the constraints that matter before writing or reviewing code.

Scan the top of the page first to identify the primary types, functions, or algorithm families involved.
Use the nearby-page links when your question is really about a companion header, related algorithm family, or broader subsystem.
Validate tricky behavior with a small compileable example before relying on memory for details like invalidation, ordering, allocation, or lifetime rules.

All Smart Pointers and Ownership Types

This page focuses on ownership vocabulary rather than every allocator detail.

Exclusive ownership

std::unique_ptr<T>
std::unique_ptr<T[]>
std::default_delete<T>
std::default_delete<T[]>

Shared ownership

std::shared_ptr<T>
std::weak_ptr<T>
std::enable_shared_from_this<T>

Construction helpers

std::make_unique
std::make_unique_for_overwrite
std::make_shared
std::allocate_shared
std::make_shared_for_overwrite
std::allocate_shared_for_overwrite

Pointer casts for shared ownership

std::static_pointer_cast
std::dynamic_pointer_cast
std::const_pointer_cast
std::reinterpret_pointer_cast

Observing and non-owning views

raw pointers such as T*
references such as T& and const T&
std::observer_ptr<T> is not in the standard library
std::span<T> for non-owning contiguous ranges
std::string_view for non-owning string-like ranges
std::reference_wrapper<T> for copyable reference semantics

Ownership-adjacent utilities

std::allocator<T>
std::pmr::polymorphic_allocator<T>
std::pmr::memory_resource
std::owner_less<T>
std::to_address

Practical rules

Prefer std::unique_ptr by default when one owner is enough.
Use std::shared_ptr only when lifetime is truly shared.
Use std::weak_ptr to break cycles and to observe shared ownership safely.
Prefer references, pointers, std::span, and std::string_view for non-owning access.

Example in practice

#include <memory>

int main() {
    auto owner = std::make_unique<int>(42);
    auto shared = std::make_shared<int>(*owner);
    owner.reset();
    return *shared;
}