{"id":445,"date":"2023-06-11T22:39:53","date_gmt":"2023-06-11T22:39:53","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=445"},"modified":"2023-08-23T16:21:47","modified_gmt":"2023-08-23T16:21:47","slug":"using-stdspan-cpp20-practical-guide","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/","title":{"rendered":"Using std::span in C++20: A Practical Guide"},"content":{"rendered":"\n

C++, a language known for its performance and efficiency. With each new standard release, it offers more features and tools that make coding in it more robust and convenient. One such tool, introduced in C++20, is std::span<\/strong><\/code>.<\/p>\n\n\n\n

In this practical guide, we will delve into std::span<\/strong><\/code> and its utility in contemporary C++ programming. This lightweight, non-owning reference to an array or a part of an array has the potential to streamline your code, reducing redundancy and enhancing clarity.<\/p>\n\n\n\n

Whether you’re working with arrays, vectors, or other data structures, std::span<\/strong><\/code> can be a versatile tool in your C++ toolbox. It bridges the gap between dynamic and static containers, providing a degree of flexibility that C++ programmers have long sought.<\/p>\n\n\n\n

Through the course of this article, we will explore what std::span<\/strong><\/code> is, why it’s a valuable addition to C++20, and how to use it effectively in your code. This guide is packed with real-world examples to help you grasp the concept and start applying it in your own projects.<\/p>\n\n\n\n

Basics of std::span<\/code><\/h2>\n\n\n\n

To appreciate the value std::span<\/strong><\/code> brings to C++20, we first need to understand its definition and purpose. At its core, std::span<\/strong><\/code> is a simple tool designed to enhance the way we handle data sequences in C++.<\/p>\n\n\n\n

std::span<\/strong><\/code> is a lightweight, non-owning reference to a sequence – be it an array or a part of an array. The term ‘non-owning’ is crucial here. It implies that std::span<\/strong><\/code> does not manage the lifetime of the objects it refers to. Instead, it merely provides a view or a reference to an existing sequence of data. This feature makes std::span<\/strong><\/code> an efficient tool for passing around views of contiguous sequences (like arrays) without having to copy or clone them.<\/p>\n\n\n\n

It’s also worth noting that std::span<\/strong><\/code> is not restricted to static arrays. It can work with dynamic data structures like std::vector<\/strong><\/code> and std::array<\/strong><\/code>, making it a highly versatile tool that works seamlessly with both dynamic and static containers.<\/p>\n\n\n\n

In essence, std::span<\/strong><\/code> serves as a bridge between dynamic and static worlds, offering a unified, efficient way to handle data sequences in C++. It’s a testament to the C++ ethos of zero-overhead abstraction – you get a high-level view of your data without sacrificing performance.<\/p>\n\n\n\n

Creating and Initializing std::span<\/code><\/h2>\n\n\n\n

Creating and initializing std::span<\/strong><\/code> is straightforward and intuitive. To define a std::span<\/strong><\/code>, you need to provide the type of elements the std::span<\/strong><\/code> will reference and optionally the extent of the std::span<\/strong><\/code>, which is the number of elements it can hold.<\/p>\n\n\n\n

Here is a basic example of defining a std::span<\/strong><\/code>:<\/p>\n\n\n

std<\/span>::span<int<\/span>> my_span;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
In this case, my_span<\/code> is a std::span<\/code> that refers to a sequence of int<\/code> elements. Note that at this point, my_span<\/code> doesn’t yet reference any actual data.<\/p>\n\n\n\n
To initialize a std::span<\/code>, you can use an array, a pointer with a size, two pointers, or a container like std::vector<\/code> or std::array<\/code>. Let’s take a look at some examples:<\/p>\n\n\n\n
Initializing with an array:<\/h3>\n\n\n
int<\/span> my_array[5<\/span>] = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\nstd<\/span>::span<int<\/span>> span_from_array<\/span>(my_array)<\/span><\/span>;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
Initializing with two pointers:<\/h3>\n\n\n
int<\/span> my_array[5<\/span>] = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\nstd<\/span>::span<int<\/span>> span_from_pointers<\/span>(&my_array[0<\/span>], &my_array[4<\/span>])<\/span><\/span>;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
Initializing with a pointer and size:<\/h3>\n\n\n
int<\/span> my_array[5<\/span>] = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\nstd<\/span>::span<int<\/span>> span_from_pointer_and_size<\/span>(my_array, 5<\/span>)<\/span><\/span>;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
Initializing with a container:<\/h3>\n\n\n
std<\/span>::vector<\/span><int<\/span>> my_vector = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\nstd<\/span>::span<int<\/span>> span_from_vector<\/span>(my_vector)<\/span><\/span>;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
Remember, std::span<\/code> does not own the data it refers to. So if the data it points to is destroyed or goes out of scope, the std::span<\/code> will be left dangling. Always be mindful of the lifetime of your data when working with std::span<\/code>.<\/p>\n\n\n\n
Accessing Elements in std::span<\/code><\/h2>\n\n\n\n
Just like with other containers in C++, you can easily access the elements in a std::span<\/code>. You can use the array subscript operator ([]<\/code>) or the at()<\/code> member function, similar to how you would with an array or std::vector<\/code>.<\/p>\n\n\n\n
Here’s how you might do it:<\/p>\n\n\n
std<\/span>::vector<\/span><int<\/span>> my_vector = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\nstd<\/span>::span<int<\/span>> my_span<\/span>(my_vector)<\/span><\/span>;\n\n\/\/ Accessing elements<\/span>\nint<\/span> first_element = my_span[0<\/span>];\nint<\/span> second_element = my_span.at(1<\/span>);<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
Note that while the array subscript operator ([]<\/code>) does not perform bounds checking, the at()<\/code> function does and will throw an exception (std::out_of_range<\/code>) if you attempt to access an element outside the valid range.<\/p>\n\n\n\n
In addition to accessing individual elements, std::span<\/code> provides several utility functions to work with the sequence:<\/p>\n\n\n\n
    \n
  • size()<\/code>: Returns the number of elements in the std::span<\/code>.<\/li>\n\n\n\n
  • length()<\/code>: This is an alias for size()<\/code>. It also returns the number of elements in the std::span<\/code>.<\/li>\n\n\n\n
  • empty()<\/code>: Checks if the std::span<\/code> is empty (i.e., whether its size is 0).<\/li>\n<\/ul>\n\n\n\n
    Here’s an example:<\/p>\n\n\n
    std<\/span>::vector<\/span><int<\/span>> my_vector = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\nstd<\/span>::span<int<\/span>> my_span<\/span>(my_vector)<\/span><\/span>;\n\n\/\/ Using utility functions<\/span>\nsize_t<\/span> num_elements = my_span.size(); \/\/ returns 5<\/span>\nbool<\/span> is_empty = my_span.empty(); \/\/ returns false<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    Manipulating std::span<\/code><\/h2>\n\n\n\n
    std::span<\/code> is a versatile tool, not just for accessing elements, but also for manipulating the viewed sequence. It offers several functions that allow us to create subviews of the original sequence, essentially providing us with slices of our data. These functions include first()<\/code>, last()<\/code>, and subspan()<\/code>.<\/p>\n\n\n\n
      \n
    • first(count)<\/code>: Creates a new std::span<\/code> that covers the first count<\/code> elements of the original std::span<\/code>.<\/li>\n\n\n\n
    • last(count)<\/code>: Creates a new std::span<\/code> that covers the last count<\/code> elements of the original std::span<\/code>.<\/li>\n\n\n\n
    • subspan(offset, count)<\/code>: Creates a new std::span<\/code> that starts from the offset<\/code> and spans count<\/code> elements of the original std::span<\/code>.<\/li>\n<\/ul>\n\n\n\n
      Here are some examples of these functions in action:<\/p>\n\n\n
      std<\/span>::vector<\/span><int<\/span>> my_vector = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>, 10<\/span>};\nstd<\/span>::span<int<\/span>> my_span<\/span>(my_vector)<\/span><\/span>;\n\n\/\/ Using first() to create a subspan<\/span>\nstd<\/span>::span<int<\/span>> first_half = my_span.first(5<\/span>); \/\/ Contains {1, 2, 3, 4, 5}<\/span>\n\n\/\/ Using last() to create a subspan<\/span>\nstd<\/span>::span<int<\/span>> last_half = my_span.last(5<\/span>); \/\/ Contains {6, 7, 8, 9, 10}<\/span>\n\n\/\/ Using subspan() to create a subspan<\/span>\nstd<\/span>::span<int<\/span>> middle = my_span.subspan(3<\/span>, 4<\/span>); \/\/ Contains {4, 5, 6, 7}<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
      Remember, these subspans are just views of the original data. They don’t own the data they’re viewing, and they don’t copy or move anything around. This makes these operations extremely efficient.<\/p>\n\n\n\n
      Using std::span<\/code> with Other STL Containers<\/h2>\n\n\n\n
      One of the great benefits of std::span<\/code> is its ability to work seamlessly with other Standard Template Library (STL) containers. You can initialize a std::span<\/code> with any STL container that provides contiguous storage, like std::vector<\/code> or std::array<\/code>.<\/p>\n\n\n\n
      Here are some examples:<\/p>\n\n\n
      \/\/ With std::vector<\/span>\nstd<\/span>::vector<\/span><int<\/span>> my_vector = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\nstd<\/span>::span<int<\/span>> span_from_vector<\/span>(my_vector)<\/span><\/span>;\n\n\/\/ With std::array<\/span>\nstd<\/span>::array<\/span><int<\/span>, 5> my_array = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\nstd<\/span>::span<int<\/span>> span_from_array<\/span>(my_array)<\/span><\/span>;<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
      In these examples, span_from_vector<\/code> and span_from_array<\/code> provide a view of the data stored in my_vector<\/code> and my_array<\/code>, respectively. You can then use this std::span<\/code> to access and manipulate the data in a unified manner, regardless of whether the underlying container is a std::vector<\/code> or a std::array<\/code>.<\/p>\n\n\n\n
      This unified access is one of the key strengths of std::span<\/code>. It allows you to write generic code that operates on a sequence of data, without caring about the specific type of the underlying container. This can greatly enhance the reusability and flexibility of your code.<\/p>\n\n\n\n
      Using std::span<\/code> in Functions<\/h2>\n\n\n\n
      A common use case for std::span<\/code> is as function parameters. When a function needs to operate on a sequence of data, it can take a std::span<\/code> as a parameter. This allows the function to be agnostic about the type of container that stores the data, as long as it provides contiguous storage.<\/p>\n\n\n\n
      This is advantageous for several reasons:<\/p>\n\n\n\n
        \n
      • Flexibility<\/strong>: The function can accept any type of container (like std::array<\/code>, std::vector<\/code>, or even a C-style array), enhancing its reusability.<\/li>\n\n\n\n
      • Efficiency<\/strong>: As std::span<\/code> does not own the data it points to and does not involve any deep copying, it’s a lightweight and efficient way of passing around views of data.<\/li>\n\n\n\n
      • Clarity<\/strong>: By using std::span<\/code>, you signal to the readers of your code that the function does not take ownership of the data and does not modify its lifetime.<\/li>\n<\/ul>\n\n\n\n
        Here’s an example of a function that takes a std::span<\/code> as a parameter:<\/p>\n\n\n
        void<\/span> print_elements<\/span>(std<\/span>::span<int<\/span>> numbers)<\/span> <\/span>{\n    for<\/span> (int<\/span> number : numbers) {\n        std<\/span>::cout<\/span> << number << \" \"<\/span>;\n    }\n    std<\/span>::cout<\/span> << std<\/span>::endl<\/span>;\n}\n\n\/\/ Usage with different containers:<\/span>\nstd<\/span>::vector<\/span><int<\/span>> my_vector = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\nprint_elements(my_vector); \/\/ Can pass std::vector<\/span>\n\nstd<\/span>::array<\/span><int<\/span>, 5> my_array = {6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>, 10<\/span>};\nprint_elements(my_array); \/\/ Can pass std::array<\/span>\n\nint<\/span> my_c_array[5<\/span>] = {11<\/span>, 12<\/span>, 13<\/span>, 14<\/span>, 15<\/span>};\nprint_elements(my_c_array); \/\/ Can pass C-style array<\/span><\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Safety Considerations and Limitations of std::span<\/code><\/h2>\n\n\n\n
        While std::span<\/code> is a powerful tool, it’s important to remember the safety considerations and limitations that come with it.<\/p>\n\n\n\n
        Safety Considerations<\/h3>\n\n\n\n
        The main safety concern with std::span<\/code> is its non-owning nature. std::span<\/code> provides a view into a sequence of data but does not own or manage the lifetime of that data. This means that if the original data is modified or destroyed while a std::span<\/code> is still pointing to it, the std::span<\/code> will be left dangling. This can lead to undefined behavior and hard-to-track bugs.<\/p>\n\n\n\n
        Therefore, it’s crucial to always be mindful of the lifetime of your data when working with std::span<\/code>. Avoid returning std::span<\/code> from functions if there’s any chance that the data it points to could go out of scope.<\/p>\n\n\n\n
        Limitations<\/h3>\n\n\n\n
        std::span<\/code> can only handle sequences that provide contiguous storage. This means it can work with arrays, std::array<\/code>, std::vector<\/code>, and similar containers, but not with containers like std::list<\/code> or std::map<\/code> that do not guarantee contiguous storage.<\/p>\n\n\n\n
        Furthermore, std::span<\/code> is not designed to replace other STL containers. It lacks features like memory management, dynamic resizing, or element insertion and deletion. Instead, std::span<\/code> is meant to complement these containers, providing a lightweight and efficient way to view and pass around their data.<\/p>\n","protected":false},"excerpt":{"rendered":"
        C++, a language known for its performance and efficiency. With each new standard release, it offers more features and tools that make coding in it more robust and convenient. One such tool, introduced in C++20, is std::span. In this practical guide, we will delve into std::span and its utility in contemporary C++ programming. This lightweight, […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_post_was_ever_published":false},"categories":[9,4],"tags":[],"class_list":["post-445","post","type-post","status-publish","format-standard","category-cplusplus","category-programming-languages","entry"],"yoast_head":"\nUsing std::span in C++20: A Practical Guide<\/title>\n<meta name=\"description\" content=\"Discover how to use std::span in C++20 with our detailed, practical guide. With code examples and clear explanations\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Using std::span in C++20: A Practical Guide\" \/>\n<meta property=\"og:description\" content=\"Discover how to use std::span in C++20 with our detailed, practical guide. With code examples and clear explanations\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-06-11T22:39:53+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-08-23T16:21:47+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/using-stdspan-cpp20-practical-guide\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/using-stdspan-cpp20-practical-guide\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"Using std::span in C++20: A Practical Guide\",\"datePublished\":\"2023-06-11T22:39:53+00:00\",\"dateModified\":\"2023-08-23T16:21:47+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/using-stdspan-cpp20-practical-guide\\\/\"},\"wordCount\":1240,\"commentCount\":0,\"articleSection\":[\"C++\",\"Programming Languages\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/using-stdspan-cpp20-practical-guide\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/using-stdspan-cpp20-practical-guide\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/using-stdspan-cpp20-practical-guide\\\/\",\"name\":\"Using std::span in C++20: A Practical Guide\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2023-06-11T22:39:53+00:00\",\"dateModified\":\"2023-08-23T16:21:47+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"Discover how to use std::span in C++20 with our detailed, practical guide. With code examples and clear explanations\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/using-stdspan-cpp20-practical-guide\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/using-stdspan-cpp20-practical-guide\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/using-stdspan-cpp20-practical-guide\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Using std::span in C++20: A Practical Guide\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Using std::span in C++20: A Practical Guide","description":"Discover how to use std::span in C++20 with our detailed, practical guide. With code examples and clear explanations","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/","og_locale":"en_US","og_type":"article","og_title":"Using std::span in C++20: A Practical Guide","og_description":"Discover how to use std::span in C++20 with our detailed, practical guide. With code examples and clear explanations","og_url":"https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/","article_published_time":"2023-06-11T22:39:53+00:00","article_modified_time":"2023-08-23T16:21:47+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"Using std::span in C++20: A Practical Guide","datePublished":"2023-06-11T22:39:53+00:00","dateModified":"2023-08-23T16:21:47+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/"},"wordCount":1240,"commentCount":0,"articleSection":["C++","Programming Languages"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/","url":"https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/","name":"Using std::span in C++20: A Practical Guide","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2023-06-11T22:39:53+00:00","dateModified":"2023-08-23T16:21:47+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"Discover how to use std::span in C++20 with our detailed, practical guide. With code examples and clear explanations","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/using-stdspan-cpp20-practical-guide\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"Using std::span in C++20: A Practical Guide"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1781352167","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/445","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=445"}],"version-history":[{"count":11,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/445\/revisions"}],"predecessor-version":[{"id":485,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/445\/revisions\/485"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=445"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=445"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=445"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}