Span Size and Stack Overflow

There is no inherent limit to the size of a std::span itself. A std::span is a lightweight object that consists of just a pointer to the first element and a size. The size of a std::span object is constant regardless of the number of elements it spans.

However, the data that a std::span points to can be stored on the stack, and the stack does have a limit. If you create a very large array on the stack and then create a std::span from it, you could potentially overflow the stack:

1int main() {
2  int large_array[1000000];
3  std::span<int> span{large_array};
4}

In this case, the problem is not the std::span itself, but the large array it's spanning. Allocating a large array on the stack can lead to stack overflow.

To avoid this, you can allocate the array on the heap instead, using a std::vector or dynamically allocated array:

1int main() {
2  std::vector<int> large_vec(1000000);
3  std::span<int> span{large_vec};
4}

Here, the large array is allocated on the heap by the std::vector, so there's no risk of stack overflow.

Remember, a std::span is just a view into data stored elsewhere. It's the elsewhere that you need to be mindful of. If that data is on the stack, then you need to be careful about the size. If it's on the heap, then the size is limited by the available heap memory, which is usually much larger than the stack.