Lifetime of a Span

No, it is not safe to use a std::span after the data it spans has gone out of scope. A std::span does not own the data it points to, so if the original data is destroyed, the std::span will be left pointing to invalid memory.

Consider this example:

1#include <span>
2#include <vector>
3#include <iostream>
4
5std::span<int> CreateSpan() {
6  std::vector<int> vec{1, 2, 3, 4, 5};
7  return std::span<int>{vec};  
8}
9
10int main() {
11  std::span<int> span = CreateSpan();
12  // vec no longer exists here
13  for (int i : span) {      
14    std::cout << i << "\n";  
15  }
16}

1-572662307
2-572662307
3-572662307
4-572662307
5-572662307

In this code, the std::vector vec is created inside the CreateSpan function. A std::span is created from vec and returned from the function. However, vec is destroyed when CreateSpan ends, because it's a local variable.

In main, when we try to use span, we're accessing memory that has already been freed. This is undefined behavior and can lead to crashes or subtle bugs.

To avoid this, ensure that the std::span does not outlive the data it spans. One way to do this is to pass the data and the span around together:

1#include <span>
2#include <vector>
3
4void ProcessData(
5  std::vector<int> vec, std::span<int> span) {
6  // Use vec and span here
7}
8
9int main() {
10  std::vector<int> vec{1, 2, 3, 4, 5};
11  ProcessData(vec, std::span<int>{vec});
12}

Here, vec and span are passed to ProcessData together, and vec outlives span, so it's safe to use span inside ProcessData.

Another way is to ensure that the data outlives the span by allocating it on the heap:

1#include <span>
2#include <vector>
3#include <memory>
4
5int main() {
6  auto vec = std::make_unique<
7    std::vector<int>>(1, 2, 3, 4, 5);
8  std::span<int> span{*vec};
9  // Use span here
10}

In this case, vec is allocated on the heap and it will live until the end of main, so it's safe to use span throughout main.