Array Views using std::span

In the previous lesson, we introduced classic, C-style arrays. We also outlined some of their main problems and recommended they not be used because of those issues.

But sometimes, we can’t avoid them. In complex projects, we’ll often integrate with third-party libraries, or APIs provided by the platforms or operating systems we’re building for. Those libraries may provide us with C-style arrays, or expect us to provide them as arguments for their functions.

C++20 introduced the std::span class to help us work with these arrays, while mitigating most of their problems.

Creating Spans

The std::span template class is available by including <span> and can be constructed in the same way as any other object. We can provide a template parameter to specify what type of objects will be in the span:

1#include <span>
2std::span<int> Span{Values};
3

Below, we create a std::span that is connected to a C-style array. Using class template argument deduction, we don’t need to explicitly state the elements are integers in this case:

1#include <span>
2
3int main(){
4  int Values[]{1, 2, 3, 4, 5};
5  std::span Span{Values};
6}
7

By connected, we mean that the span has not created a copy of the elements. It simply provides a lightweight interface with which to access and work with the underlying array. We’ll discuss these properties in more detail a little later.

Span Size

The most common place we’ll use a span is as a function parameter type, to receive a C-style array argument:

1#include <span>
2#include <iostream>
3
4void HandleValues(std::span<int> Values){
5  std::cout << "Span Size: " << Values.size();
6}
7
8int main(){
9  int Values[]{1, 2, 3, 4, 5};
10  HandleValues(Values);
11}
12

1Span Size: 5
2

This example shows spans overcoming the first big problem with C-style arrays - the fact they decay to a pointer, and lose track of their size. With spans, this doesn’t happen - we’ve received a regular type, and we can access its size using the size() method.

Element Access

Similar to containers like std::vector and std::array, we can access elements using the [] operator, using an index or an expression that results in an index:

1#include <span>
2#include <iostream>
3
4int main(){
5  int Values[]{1, 2, 3, 4, 5};
6  std::span<int> Span{Values};
7  std::cout
8    << "First: " << Span[0]
9    << "\nSecond: " << Span[1]
10    << "\nLast: " << Span[Span.size() - 1];
11}
12

1First: 1
2Second: 2
3Last: 5
4

The front() and back() methods give us direct access to the first and last elements of the span:

1#include <span>
2#include <iostream>
3
4int main(){
5  int Values[]{1, 2, 3, 4, 5};
6  std::span<int> Span{Values};
7  std::cout
8    << "First: " << Span.front()
9    << "\nLast: " << Span.back();
10}
11

1First: 1
2Last: 5
3

Spans are a View

Spans are an example of a view - they do not own the underlying elements they’re providing access to. Those are owned by a different container - for example, the C-style array we passed to the std::span constructor.

This has two effects - Firstly, when it comes to performance, creating a span is inexpensive. This is because they don’t need to copy any of the underlying elements.

Secondly, when we change an element of the underlying array, that change is reflected in the span:

1#include <span>
2#include <iostream>
3
4int main(){
5  int Values[]{1, 2, 3, 4, 5};
6  std::span<int> Span{Values};
7  Values[0] = 42;
8  std::cout << "First: " << Span.front();
9}
10

1First: 42
2

The opposite is also true - changing an element through the span also affects the original container from which the span was constructed:

1#include <span>
2#include <iostream>
3
4int main(){
5  int Values[]{1, 2, 3, 4, 5};
6  std::span<int> Span{Values};
7  Span[0] = 42;
8  std::cout << "First: " << Values[0];
9}
10

1First: 42
2

The const Keyword with Spans

In most scenarios, we want the span to be a read-only view of the container from which it was created.

We can be explicit about this using the const keyword. We can specify that the individual elements will not be changed, by marking their type as const:

1#include <span>
2
3int main(){
4  int Values[]{1, 2, 3, 4, 5};
5  std::span<const int> Span{Values};
6  Span[0] = 42; // Error - Span[n] is const 
7}
8

We can also make the span itself const, which will prevent it from being reassigned:

1#include <span>
2
3int main(){
4  int Values[]{1, 2, 3, 4, 5};
5  const std::span<int> Span{Values};
6  Span = Values; // Error - Span is const 
7}
8

Finally, we can combine both techniques using the const specifier twice, to ensure neither the span, nor the elements it is viewing are modified:

1#include <span>
2
3int main(){
4  int Values[]{1, 2, 3, 4, 5};
5  const std::span<const int> Span{Values};
6  Span[0] = 42; // Error - Span[n] is const 
7  Span = Values; // Error - Span is const 
8}
9

Iteration

We can iterate over the elements of a span in the usual ways. Because spans implement iterators, we will most typically use a range-based for loop:

1#include <span>
2#include <iostream>
3
4int main(){
5  int Values[]{1, 2, 3, 4, 5};
6  std::span<int> Span{Values};
7
8  for (int x : Span) {
9    std::cout << x << ", ";
10  }
11}
12

We cover iterators and range-based for loops in more detail a little later in the course.

Multiple Array Types

Throughout this lesson, we’ve been creating spans from C-style arrays, but that is not their only use. Spans can be created from any container that holds its elements in a contiguous area of memory, such as a std::vector or std::array, or any custom type for which we provide appropriate methods.

This allows us to create functions that can potentially provide a simple, consistent interface for working with various types of arrays:

1#include <span>
2#include <iostream>
3#include <vector>
4#include <array>
5
6void LogFirst(std::span<int> Values){
7  std::cout << Values.front() << ", ";
8}
9
10int main(){
11  int ValuesA[]{1, 2, 3, 4};
12  std::vector ValuesB{5, 6, 7};
13  std::array ValuesC{8, 9};
14
15  LogFirst(ValuesA);
16  LogFirst(ValuesB);
17  LogFirst(ValuesC);
18}
19

11, 5, 9,
2

Span Templates

Remember, we also have access to all of the template-based techniques we covered in the previous lesson, allowing us to create even more versatile code:

1#include <span>
2#include <iostream>
3#include <vector>
4#include <array>
5
6template <typename T>
7void LogFirst(std::span<T> Values){
8  std::cout << Values.front() << ", ";
9}
10
11int main(){
12  int ValuesA[]{1, 2, 3, 4};
13  std::vector ValuesB{5.f, 6.f, 7.f};
14  std::array ValuesC{true, false};
15
16  LogFirst<int>(ValuesA);
17  LogFirst<float>(ValuesB);
18  LogFirst<bool>(ValuesC);
19}
20

11, 5, 1, 
2

Creating C-Style Arrays from Spans

When we need to get a C-style array from a span, we can access a pointer to the first element using the data() method.

Typically, the use case for this will be to generate arguments for a third-party library, in which case we’ll typically also need to include the size:

1#include <span>
2#include <iostream>
3
4void HandleArray(int Array[], size_t Size){
5  for (size_t i{0}; i < Size; ++i) {
6    std::cout << Array[i] << ", ";
7  }
8}
9
10int main(){
11  int Values[]{1, 2, 3, 4, 5};
12  std::span<int> Span{Values};
13  HandleArray(Span.data(), Span.size());
14}
15

11, 2, 3, 4, 5,
2

Note this technique will create a shallow copy of the array. If we want a deep copy of all elements in the array, we’ll need to use one of the techniques covered in the previous lesson on C-style arrays.

Creating Vectors and Arrays from Spans

When we need to create a standard library container such as an array or span, the easiest way typically involves iterator pairs.

We cover iterators in more detail but, for now, we can just note that spans include a begin() and end() method, denoting where their elements start and where they end.

Standard library containers such as std::vector and std::array have a constructor that can accept such a pair of iterators, and will use them to initialize themselves with a copy of everything in that range:

1#include <iostream>
2#include <vector>
3#include <span>
4
5int main(){
6  int Values[]{1, 2, 3, 4, 5};
7  std::span<int> Span{Values};
8  std::vector<int> Vec{
9    Span.begin(), Span.end()
10  };
11}
12

The typical scenario where we’ll want to convert a span to a vector or array is in order to pass it as a function argument. In those cases, we shouldn’t create an intermediate copy of the array - we can just pass the constructor arguments as a list, and let our function call create the vector:

1#include <iostream>
2#include <vector>
3#include <span>
4
5void HandleVector(std::vector<int> Vec){
6  for (int x : Vec) { std::cout << x << ", "; }
7}
8
9int main(){
10  int Values[]{1, 2, 3, 4, 5};
11  std::span<int> Span{Values};
12  HandleVector(
13    {Span.begin(), Span.end()}
14  );
15}
16

11, 2, 3, 4, 5,
2

Creating Spans and Subspans from Spans

Spans can be created from other spans in the usual way:

1#include <span>
2#include <iostream>
3
4int main(){
5  int Values[]{1, 2, 3, 4, 5};
6  std::span<int> Span{Values}; 
7  std::span<int> Another{Span};
8
9  for (int x : Another) {
10    std::cout << x << ", ";
11  }
12}
13

These spans can also be restricted to just including a subset of the original span. For example, using the first() method, we can restrict the sub span to just viewing an initial number of records, defined by the argument we pass:

1#include <span>
2#include <iostream>
3
4int main(){
5  int Values[]{1, 2, 3, 4, 5};
6  std::span<int> Span{Values};
7  std::span<int> First3{Span.first(3)}; 
8
9  std::cout << "First Three: ";
10  for (int x : First3) {
11    std::cout << x << ", ";
12  }
13}
14

1First Three: 1, 2, 3,
2

The last() method returns a span that includes records from the end of the collection. Below, we return a view of the last 3 elements:

1#include <span>
2#include <iostream>
3
4int main(){
5  int Values[]{1, 2, 3, 4, 5};
6  std::span<int> Span{Values};
7  std::span<int> Last3{Span.last(3)}; 
8
9  std::cout << "Last Three: ";
10  for (int x : Last3) {
11    std::cout << x << ", ";
12  }
13}
14

1Last Three: 3, 4, 5,
2

Finally, we can pass a starting position and record count to the subspan() method, constraining the view to any range. Below, we return a view that starts at index 1, and contains 3 elements:

1#include <span>
2#include <iostream>
3
4int main(){
5  int Values[]{1, 2, 3, 4, 5};
6  std::span<int> Span{Values};
7  std::span<int> Middle3{Span.subspan(1, 3)}; 
8
9  std::cout << "Middle Three: ";
10  for (int x : Middle3) {
11    std::cout << x << ", ";
12  }
13}
14

Remember, spans are just a view of an underlying record. This includes spans created from other spans. A subspan is just restricting the view to a smaller set of elements in the underlying array. The elements we’re viewing are still the elements in that array, and by accessing them through the span, we are still accessing the elements of the underlying array.

Views are a large part of modern C++, and a span is just one type of view. We’ll cover views in more detail later in this course, including more robust ways to create them, and how we can use them to make complex tasks much easier.