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

NAME
     std::dynamic_extent - std::dynamic_extent

Synopsis
	Defined in header <span>
	inline	      constexpr        std::size_t	  dynamic_extent       =
     (since C++20)
	std::numeric_limits<std::size_t>::max();

	std::dynamic_extent is a constant of type std::size_t that is  generally
     used to
	indicate  that any type using std::dynamic_extent will dynamically store
     its value
	(e.g., size) rather than having the value statically known in the type.

	It is being used in several contexts:

	  * To differentiate std::span of static and dynamic extent.

	  * To indicate that the extent at a certain rank index will  be  stored
     (since C++23)
	    dynamically in std::extents.

	  *   To   indicate   that  the  padded  layouts  for  std::mdspan  will
     (since C++26)
	    dynamically store its padding value.

Note
	Since std::size_t is an unsigned type, an equivalent definition is:

      inline constexpr std::size_t dynamic_extent = -1;

	See integral conversions.

Example
     // Run this code

      #include <array>
      #include <cassert>
      #include <cstddef>
      #include <iostream>
      #include <span>
      #include <string_view>
      #include <vector>

      int main()
      {
	  auto print = [](std::string_view const name, std::size_t ex)
	  {
	      std::cout << name << ", ";
	      if (std::dynamic_extent == ex)
		  std::cout << "dynamic extent\n";
	      else
		  std::cout << "static extent = " << ex << '\n';
	  };

	  int a[]{1, 2, 3, 4, 5};

	  std::span span1{a};
	  print("span1", span1.extent);

	  std::span<int, std::dynamic_extent> span2{a};
	  print("span2", span2.extent);

	  std::array ar{1, 2, 3, 4, 5};
	  std::span span3{ar};
	  print("span3", span3.extent);

	  std::vector v{1, 2, 3, 4, 5};
	  std::span span4{v};
	  print("span4", span4.extent);
      }

Output:
      span1, static extent = 5
      span2, dynamic extent
      span3, static extent = 5
      span4, dynamic extent

See also
	span	a non-owning view over a contiguous sequence of objects
	(C++20) (class template)
	extents a descriptor of a multidimensional index space of some rank
	(C++23) (class template)

http://cppreference.com 	   2024.06.10		  std::dynamic_extent(3)
home | help