What is std::span in C++?

Introduced in C++20, std::span is a powerful class template defined in the <span> header, offering a non-owning view of a container in the C++ Standard Library. It serves as a safer alternative to using raw pointers and size information to represent a sequence of elements.

A span provides bounds-checked access to a contiguous group of elements, including arrays, strings, or vectors, without actually owning the data. Instead of holding separate pointers or iterators and length fields, a span unifies both into a single object, making it lightweight and efficient.

The primary focus of std::span is to enhance code safety and robustness. By using std::span, developers can avoid common pitfalls like null pointer dereferences and buffer overflows, contributing to more reliable and maintainable codebases.

Moreover, std::span is fully compatible with standard algorithms and interfaces that operate on contiguous data, making it seamlessly integrate into existing C++ codebases. As a result, adopting std::span can be a simple and effective way to improve code clarity and safety without sacrificing performance.

Code example

Here’s an example of creating and using an std::span:

#include <iostream>
#include <span>
#include<vector>
void print(std::span<auto> ints) {
    for (const auto n : ints) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
}
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    char alphabets[] ={'a','b','c'};
    
    std::span<char> characters(alphabets);
    std::span<int> span(arr,5);
    print(span);
    print(characters);
    return 0;
}

Code explanation

  • Line 2: This line includes the <span> header, introduced in C++20, providing the std::span class template.

  • Lines 5–10: The print function is declared, which takes an std::span as a parameter. The use of const auto in the template parameter ensures that the function works with both std::span<T> and std::span<const T>.

  • Line 16: The first span, characters, is initialized with the alphabets array, creating a span of characters. Note that this std::span<char> does not include the null-terminator of alphabets, making it suitable for working with raw character data.

  • Line 17: An std::span<int> object named span is created, which references the arr array. The span covers the entire array, and the second argument (5) specifies the number of elements in the array.

  • Lines 19–20: These lines call the print function, passing the span and characters spans as arguments. The print function prints the elements of each span, demonstrating how std::span enables seamless iteration over different types of sequences.

The key advantage of std::span is its ability to work with sequences of elements without copying or transferring ownership. As a non-owning view, it provides a uniform interface for accessing the elements, allowing us to treat arrays, containers, and other sequences interchangeably. It is particularly useful in function parameters, where we can pass std::span instead of raw pointers or containers, enabling safer and more efficient function calls.

Note: The std::span class template provides various member functions and operators to access and manipulate the elements, such as size(), operator[], front(), back(), etc. Additionally, std::span supports slicing to create sub-spans and allows us to convert between spans of different element types, making it a versatile tool for working with contiguous data in C++.

Free AI Mock Interviews
Coding Interview
Coding PatternsFree Interview
Gain insights and practical experience with coding patterns through targeted MCQs and coding problems, designed to match and challenge your expertise level.
System Design
YouTubeFree Interview
Learn to design a video streaming platform like YouTube by tackling functional and non-functional requirements, core components, and high-level to detailed design challenges.

Free Resources

Copyright ©2025 Educative, Inc. All rights reserved