Skip to content

Search topics & cppreference

Search all study topics, concept maps, and 6,587 C++ and C reference pages.

std::dynamic_extent

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.

Containers
  • C++20
  • C++23
  • C++26
1 min readView on cppreference
NotebookLM
Defined in header <span>
inline constexpr std::size_t dynamic_extent = std::numeric_limits<std::size_t>::max();
(since C++20)

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 dynamically in std::extents.
(since C++23)
  • To indicate that the padded layouts for std::mdspan will dynamically store its padding value.
(since C++26)

Note

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

snippet.cpp
inline constexpr std::size_t dynamic_extent = -1;

See integral conversions.

Example

example.cpp
#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

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

Content from this page on cppreference.com, licensed under CC-BY-SA 3.0 and GFDL. Modified: restyled, site navigation removed, code windows added. Offline snapshot of 9 February 2025.