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 parallelism 2 (parallelism TS v2)
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
Concept utilities
Iterator utilities and operations
Iterator traits
Iterator adaptors
Stream iterators
template <CopyConstructible T>

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

(ranges TS)
template<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.

Member functions


dangling() requires 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.