std::experimental::ranges::dangling, std::experimental::ranges::safe_iterator_t

< cpp‎ | experimental‎ | ranges
Technical specifications
Filesystem library (filesystem TS)
Library fundamentals (library fundamentals TS)
Library fundamentals 2 (library fundamentals 2 TS)
Extensions for parallelism (parallelism TS)
Extensions for concurrency (concurrency TS)
Concepts (concepts TS)
Ranges (ranges TS)
Special mathematical functions (special math TR)
Iterators library
Iterator concepts
Indirect callable concepts
Common algorithm requirements
Range concepts
Concept utilities
Iterator utilities and operations
Iterator traits
Iterator adaptors
Stream iterators
Range access
Range primitives
template <ranges::CopyConstructible T>

class dangling {
    dangling() requires ranges::DefaultConstructible<T>();
    dangling(T t);
    T get_unsafe() const;

(ranges TS)
template<ranges::Range R>

using safe_iterator_t = std::conditional_t<std::is_lvalue_reference<R>::value,

(ranges TS)

The class template dangling is a simple wrapper around an object to indicate that the wrapped object may be dangling, that is, it refers to another object whose lifetime may have ended.

The alias template safe_iterator_t returns the iterator type of R, wrapped in dangling if the range was an rvalue range (as indicated by R not being an lvalue reference type).

They are used by range algorithms that accept rvalue ranges and return iterators into them.

[edit] Member functions


dangling() requires ranges::DefaultConstructible<T>();
dangling(T t);
1) Default constructor. Value-initializes the wrapped object.
2) Initializes the wrapped object with t. Note that this constructor defines an implicit conversion from T to dangling<T>.


T get_unsafe() const;

Returns a copy of the wrapped object.