Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::ranges::dangling(3)      C++ Standard Libary     std::ranges::dangling(3)

NAME
       std::ranges::dangling - std::ranges::dangling

Synopsis
	  Defined in header <ranges>
	  struct dangling;	      (since C++20)

	  dangling  is	a  placeholder	type and an empty class	type, used to-
       gether with the
	  template  aliases   ranges::borrowed_iterator_t   and	  ranges::bor-
       rowed_subrange_t.

	  When	some constrained algorithms that usually return	an iterator or
       a subrange of a
	  range	take a particular rvalue range argument	that  does  not	 model
       borrowed_range,
	  dangling  will  be  returned	instead	to avoid returning potentially
       dangling	results.

Member functions
       std::ranges::dangling::dangling

	  constexpr dangling() noexcept	= default;   (1)
	  template<class... Args>		     (2)
	  constexpr dangling(Args&&...)	noexcept { }

	  1) dangling is trivially default constructible.
	  2) dangling can be constructed from arguments	 of  arbitrary	number
       and arbitrary
	  non-void  type.  The	construction does not have any side-effect it-
       self.

	  In other words, after	replacing the type (e.g. an iterator type)  in
       a well-formed
	  non-aggregate	 initialization	 with dangling,	the resulting initial-
       ization is also
	  well-formed.

Example
       // Run this code

	#include <algorithm>
	#include <array>
	#include <iostream>
	#include <ranges>
	#include <type_traits>
	#include <string_view>

	int main()
	{
	    auto get_array_by_value = [] { return std::array{0,	1, 0, 1}; };
	    auto     dangling_iter     =      std::ranges::max_element(get_ar-
       ray_by_value());
	    static_assert(std::is_same_v<std::ranges::dangling,	 decltype(dan-
       gling_iter)>);
	//  std::cout << *dangling_iter	<<  '\n';  //  compilation  error:  no
       match for 'operator*'
						 //	(operand    type    is
       'std::ranges::dangling')

	    auto get_persistent_array =	[]() ->	const std::array<int, 4>& {
		static constexpr std::array a{0, 1, 0, 1};
		return a;
	    };
	    auto  valid_iter   =   std::ranges::max_element(get_persistent_ar-
       ray());
	    static_assert(!std::is_same_v<std::ranges::dangling,	   de-
       cltype(valid_iter)>);
	    std::cout << *valid_iter <<	' '; //	1

	    auto get_string_view = [] {	return std::string_view{"alpha"}; };
	    auto valid_iter2 = std::ranges::min_element(get_string_view());
		// OK: std::basic_string_view models borrowed_range
	    static_assert(!std::is_same_v<std::ranges::dangling,	   de-
       cltype(valid_iter2)>);
	    std::cout << '\'' << *valid_iter2 << '\'' << '\n'; // 'a'
	}

Output:
	1 'a'

See also
	  ranges::borrowed_iterator_t  obtains	iterator type or subrange type
       of a
	  ranges::borrowed_subrange_t borrowed_range
	  (C++20)		      (alias template)
				      specifies	that a type is a range and it-
       erators obtained
	  ranges::borrowed_range      from an expression of it can  be	safely
       returned	without
	  (C++20)		      danger of	dangling
				      (concept)

http://cppreference.com		  2022.07.31	      std::ranges::dangling(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::ranges::dangling&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help