std::span in C++20: Bounds-Safe Views for Sequences of Objects


In my seminar, I often hear the question: How can I safely pass a plain array to a function? With C++20, the answer is quite easy: Use a std::span.



A std::span stands for an object that can refer to a contiguous sequence of objects. A std::span, sometimes also called a view, is never an owner. This contiguous memory can be a plain array, a pointer with a size, a std::array, a std::vector, or a std::string. A typical implementation consists of a pointer to its first element and a size. The main reason for having a std::span<T> is that a plain array will be decay to a pointer if passed to a function; therefore, the size is lost. This decay is a typical reason for errors in C/C++.

Automatically deduces the size of a contiguous sequence of objects

In contrast, std::span<T> automatically deduces the size of contiguous sequences of objects.


// printSpan.cpp

#include <iostream>
#include <vector>
#include <array>
#include <span>

void printMe(std::span<int> container) {
    std::cout << "container.size(): " << container.size() << '\n';  // (4)
    for(auto e : container) std::cout << e << ' ';
    std::cout << "\n\n";

int main() {
    std::cout << std::endl;
    int arr[]{1, 2, 3, 4};              // (1)
    std::vector vec{1, 2, 3, 4, 5};     // (2)

    std::array arr2{1, 2, 3, 4, 5, 6}; // (3)


The C-array (1), std::vector (2), and the std::array (3) have int's. Consequently, std::span also holds int's. There is something more interesting in this simple example. For each container, std::span can deduce its size (4).

All of the big three C++ compilers MSVC, GCC, and Clang, support std::span.



There are more ways to create a std::span.

Create a std::span from a pointer and a size

You can create a std::span from a pointer and a size.

// createSpan.cpp

#include <algorithm>
#include <iostream>
#include <span>
#include <vector>

int main() {

    std::cout << std::endl;
    std::cout << std::boolalpha;

    std::vector myVec{1, 2, 3, 4, 5};
    std::span mySpan1{myVec};                                        // (1)
    std::span mySpan2{, myVec.size()};                   // (2)
    bool spansEqual = std::equal(mySpan1.begin(), mySpan1.end(),
                                 mySpan2.begin(), mySpan2.end());
    std::cout << "mySpan1 == mySpan2: " << spansEqual << std::endl;  // (3)

    std::cout << std::endl;


As you may expect, the from a std::vector created mySpan1 (1) and the from a pointer and a size created mySpan (2)  are equal (3).



You may remember that a std::span is sometimes called a view.Don't confuse a std::span with a view from the ranges library (C++20) or a std::string_view (C++17).

A view from the ranges library is something that you can apply on a range and performs some operation. A view does not own data, and it's time to copy, move, assignment it's constant. Here is a quote from Eric Nieblers range-v3 implementation, which is the base for the C++20 ranges: "Views are composable adaptations of ranges where the adaptation happens lazily as the view is iterated." These are all my posts to then ranges library: category ranges library

A view (std::span) and a std::string_view are non-owning views and can deal with strings. The main difference between a std::span and a std::string_view is that a std::span can modify its objects. When you want to read more about std::string_view, read my previous post: "C++17 - What's New in the Library?" and "C++17 - Avoid Copying with std::string_view". 

Modifying its objects

You can modify the entire span or only a subspan. When you modify the span, you modify the referenced objects..

The following program shows how a subspan can be used to modify the referenced objects from a std::vector.

// spanTransform.cpp

#include <algorithm>
#include <iostream>
#include <vector>
#include <span>

void printMe(std::span<int> container) {
    std::cout << "container.size(): " << container.size() << std::endl;
    for(auto e : container) std::cout << e << ' ';
    std::cout << "\n\n";

int main() {
    std::cout << std::endl;
    std::vector vec{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};    
    std::span span1(vec);                                 // (1) 
    std::span span2{span1.subspan(1, span1.size() - 2)};  // (2)
    std::transform(span2.begin(), span2.end(),            // (3)  
                   [](int i){ return i * i; });


span1 references the std::vector vec (1). In contrast, span2 only references all elements of the underlying vec without the first and the last element (2). Consequently, the mapping of each element to its square (3) only addresses these elements. 


There are many convenience functions to refer to the elements of the span.

Addressing the elements of a std::span

The table presents the functions to refer to the elements of a span.


Function  Description
 span.front() Access the first element
 span.back() Access the last element
 span[i] Access the i-th element Returns a pointer to the beginning of the sequence 
 span.size() Returns the number of elements of the sequence
 span.size_bytes() Returns the size of the sequence 
 span.empty() Returns if the sequence is empty



Returns a subspan consisting of the first count elements of the sequence



Returns a subspan consisting of the last count elements of the sequence

span<first, count>.subspan()

span.subspan(first, count)

Returns a subspan consisting of count elements starting at first


The small program shows the usage of the function subspan.

// subspan.cpp

#include <iostream>
#include <numeric>
#include <span>
#include <vector>

int main() {

    std::cout << std::endl;

    std::vector<int> myVec(20);
    std::iota(myVec.begin(), myVec.end(), 0);                   // (1)
    for (auto v: myVec) std::cout << v << " ";

    std::cout << "\n\n";

    std::span<int> mySpan(myVec);                               // (2)
    auto length = mySpan.size();

    auto count = 5;                                             // (3)
    for (long unsigned int first = 0; first <= (length - count); first += count ) {
        for (auto ele: mySpan.subspan(first, count)) std::cout << ele << " ";
        std::cout << std::endl;



The program fills the vector with all numbers from 0 to 19 (1), and initializes a std::span with it (2). The algorithm std::iota fills myVec with the sequentially increasing values, starting with 0. Finally, the for-loop (3) uses the function subspan to create all subspans starting at first and having count elements until mySpan is consumed.


What's next? 

Containers of the STL become with C++20 more powerful. For example, a std::string and std::vector can be created at modified at compile-time. Further, thanks to the functions std::erase and std::erase_if, the deletion of the elements of a container works like a charm.



Thanks a lot to my Patreon Supporters: Matt Braun, Roman Postanciuc, Tobias Zindl, Marko, G Prvulovic, Reinhold Dröge, Abernitzke, Frank Grimm, Sakib, Broeserl, António Pina, Sergey Agafyin, Андрей Бурмистров, Jake, GS, Lawton Shoemake, Animus24, Jozo Leko, John Breland, espkk, Louis St-Amour, Venkat Nandam, Jose Francisco, Douglas Tinkham, Kuchlong Kuchlong, Robert Blanch, Truels Wissneth, Kris Kafka, Mario Luoni, Neil Wang, Friedrich Huber, lennonli, Pramod Tikare Muralidhara, Peter Ware, Tobi Heideman, Daniel Hufschläger, Red Trip, Alexander Schwarz, Tornike Porchxidze, Alessandro Pezzato, Evangelos Denaxas, Bob Perry, Satish Vangipuram, Andi Ireland, Richard Ohnemus, Michael Dunsky, Dimitrov Tsvetomir, Leo Goodstadt, Eduardo Velasquez, John Wiederhirn, Yacob Cohen-Arazi, Florian Tischler, Robin Furness, and Michael Young.


Thanks in particular to Jon Hess, Lakshman, Christian Wittenhorst, Sherhy Pyton, Dendi Suhubdy, Sudhakar Belagurusamy, Richard Sargeant, and Rusty Fleming.



My special thanks to Embarcadero CBUIDER STUDIO FINAL ICONS 1024 Small



I'm happy to give online seminars or face-to-face seminars worldwide. Please call me if you have any questions.

Bookable (Online)


Standard Seminars (English/German)

Here is a compilation of my standard seminars. These seminars are only meant to give you a first orientation.


Contact Me

Modernes C++,





0 #1 Johan Lundberg 2021-03-29 17:45
Thanks for the write-up. Question/comment: as far as I understand span is not bounds-safe. states that operator[] is undefined behaviour on out of bounds access.
0 #2 Rainer Grimm 2021-03-31 19:33
Quoting Johan Lundberg:
Thanks for the write-up. Question/comment: as far as I understand span is not bounds-safe. states that operator[] is undefined behaviour on out of bounds access.

I should clarify. I mean that std::span automatically deduces the size of a contiguous sequence of objects.

My Newest E-Books

Course: Modern C++ Concurrency in Practice

Course: C++ Standard Library including C++14 & C++17

Course: Embedded Programming with Modern C++

Course: Generic Programming (Templates)

Course: C++ Fundamentals for Professionals

Interactive Course: The All-in-One Guide to C++20

Subscribe to the newsletter (+ pdf bundle)

Blog archive

Source Code


Today 512

Yesterday 7029

Week 40836

Month 107502

All 7375342

Currently are 161 guests and no members online

Kubik-Rubik Joomla! Extensions

Latest comments