Namespaces
Variants
Views
Actions

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

From cppreference.com
< cpp‎ | experimental‎ | ranges
 
 
Technical specifications
Filesystem library (filesystem TS)
Library fundamentals (library fundamentals TS)
Library fundamentals 2 (library fundamentals TS v2)
Library fundamentals 3 (library fundamentals TS v3)
Extensions for parallelism (parallelism TS)
Extensions for parallelism 2 (parallelism TS v2)
Extensions for concurrency (concurrency TS)
Concepts (concepts TS)
Ranges (ranges TS)
Mathematical special functions (special functions TR)
 
 
Iterators library
Iterator concepts
Indirect callable concepts
                                                  
                                                  
                                                  
Common algorithm requirements
                                                  
Concept utilities
Iterator utilities and operations
Iterator traits
Iterator adaptors
danglingborrowed_iterator_t
Stream iterators
 
template <CopyConstructible T>

class dangling {
public:
    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::iterator_t<R>,

                                           ranges::dangling<ranges::iterator_t<R>>;
(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

std::experimental::ranges::dangling::dangling

dangling() requires DefaultConstructible<T>();
(1)
dangling(T t);
(2)
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>.

std::experimental::ranges::dangling::get_unsafe

T get_unsafe() const;

Returns a copy of the wrapped object.