Using Span as a Function Parameter

Using std::span as a function parameter has several benefits over using a reference to a specific container type:

Flexibility

A function that takes a std::span can be called with any contiguous sequence of elements, regardless of how those elements are actually stored. This could be a std::vector, a std::array, a built-in array, or even another std::span. This makes the function more flexible and reusable.

1#include <span>
2#include <vector>
3#include <array>
4#include <iostream>
5
6void PrintElements(std::span<const int> elements) {
7  for (int i : elements) {
8    std::cout << i << " ";
9  }
10  std::cout << "\n";
11}
12
13int main() {
14  std::vector<int> vec{1, 2, 3};
15  std::array<int, 4> arr{4, 5, 6, 7};
16  int c_arr[] = {8, 9, 10};
17
18  PrintElements(vec);
19  PrintElements(arr);
20  PrintElements(c_arr);
21}

11 2 3
24 5 6 7
38 9 10

No Unnecessary Copying

When you pass a container by value, a copy of the container is made. For large containers, this can be expensive. When you pass a reference to a container, no copying is done, but the function is tied to a specific container type. With std::span, no copying is done, and the function can work with any container type.

Clarity of Intent

Using std::span makes it clear that the function only needs a view of the elements, and does not need to modify the container itself. This can make the code easier to understand and maintain.

Const-Correctness

You can use std::span<const T> to indicate that the function will not modify the elements. This is not possible with a non-const reference to a container.

1void ProcessElements(
2  std::span<const int> elements) {
3  // elements cannot be modified here
4}

Avoid Dangling References

If a function takes a reference to a container, and that container is a temporary object, the reference will be left dangling after the temporary object is destroyed. With std::span, the caller needs to ensure that the original data outlives the span.

1void ProcessElements(
2  const std::vector<int>& elements) {
3  // Dangling reference if elements is a temporary
4}
5
6void ProcessElements(
7  std::span<const int> elements) {
8  // No dangling reference, but caller must ensure
9  // original data outlives the span
10}

However, std::span is not always the best choice. If your function needs to modify the container itself (e.g., add or remove elements), then you need to take the container by reference. Also, std::span doesn't work well with non-contiguous containers like std::list or std::map.