{"id":8906,"date":"2024-01-15T18:56:35","date_gmt":"2024-01-15T18:56:35","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=8906"},"modified":"2024-01-15T18:56:35","modified_gmt":"2024-01-15T18:56:35","slug":"stdspan-in-c20-more-details","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/stdspan-in-c20-more-details\/","title":{"rendered":"std::span in C++20: More Details"},"content":{"rendered":"\n

A std::span<\/code> represents an object that refers to a contiguous sequence of objects. Today, I want to write about its not-so-obvious features.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

A std::span<\/code>, 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<\/code>, a std::vector<\/code>, or a std::string<\/code>. A typical implementation consists of a pointer to its first element and a size. The main reason for having a std::span<T> <\/code>is that a plain array will decay to a pointer if passed to a function; therefore, the size is lost. This decay<\/a> is a typical reason for errors in C\/C++.<\/p>\n\n\n\n

Automatically deduces the size of a contiguous sequence of objects<\/h2>\n\n\n\n

In contrast, std:<\/strong>:span<T> <\/code>automatically deduces the size of contiguous sequences of objects.<\/p>\n\n\n\n

\/\/ printSpan.cpp<\/span>\n\n#include <iostream><\/span>\n#include <vector><\/span>\n#include <array><\/span>\n#include <span><\/span>\n\nvoid<\/span> printMe<\/span>(std::<\/span>span<<\/span>int<\/span>><\/span> container) {\n    \n    std::<\/span>cout <<<\/span> "container.size(): "<\/span> <<<\/span> container.size() <<<\/span> '\\n'<\/span>;  \/\/ (4)<\/span>\n    for<\/span>(auto<\/span> e :<\/span> container) std::<\/span>cout <<<\/span> e <<<\/span> ' '<\/span>;\n    std::<\/span>cout <<<\/span> "<\/span>\\n\\n<\/span>"<\/span>;\n}\n\nint<\/span> main<\/span>() {\n    \n    std::<\/span>cout <<<\/span> std::<\/span>endl;\n    \n    int<\/span> arr[]{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>};              \/\/ (1)<\/span>\n    printMe(arr);\n    \n    std::<\/span>vector vec{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};     \/\/ (2)<\/span>\n    printMe(vec);\n\n    std::<\/span>array arr2{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>}; \/\/ (3)<\/span>\n    printMe(arr2);\n    \n}\n<\/pre><\/div>\n\n\n\n
The C-array (1), std::vector<\/code> (2), and the std::array<\/code> (3) have int<\/code>\u2018s. Consequently, std::span<\/code> also holds int<\/code>\u2019s. There is something more interesting in this simple example. For each container, std::span<\/code> can deduce its size (4).<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
This was a short reminder about std::span<\/code>. For the full story, read my previous post “std::span in C++20: Bounds-Safe Views of Sequences of Objects<\/a>“.<\/p>\n\n\n\n
A std::span<\/code> can have a static extent or a dynamic extent. <\/p>\n\n\n\n
Static versus Dynamic Extent<\/h2>\n\n\n\n
By default, std::span<\/code> has a dynamic extent:<\/p>\n\n\n\n
template<\/span> <<\/span>typename<\/span> T, std::<\/span>size_t<\/span> Extent =<\/span> std::<\/span>dynamic_extent><\/span>\nclass<\/span> span<\/span>;\n<\/pre><\/div>\n\n\n\n
When a std::span<\/code> has a static extent<\/strong><\/em>, its size is known at compile time and part of the type: std::span<\/code>. Consequently, its implementation needs only a pointer to the first element of the contiguous sequence of objects.
<\/p>\n\n\n\n
Implementing a std::span<\/code> with a dynamic extent <\/em><\/strong>consists of a pointer to the first element and the size of the contiguous sequence of objects. The size is not part of the std::span<\/code> type.
<\/p>\n\n\n\n
The next example emphasizes the differences between the two kinds of spans.<\/p>\n\n\n\n
\/\/ staticDynamicExtentSpan.cpp<\/span>\n\n#include <iostream><\/span>\n#include <span><\/span>\n#include <vector><\/span>\n\nvoid<\/span> printMe<\/span>(std::<\/span>span<<\/span>int<\/span>><\/span> container) {        \/\/ (3)  <\/span>\n    \n    std::<\/span>cout <<<\/span> "container.size(): "<\/span> <<<\/span> container.size() <<<\/span> '\\n'<\/span>;\n    for<\/span> (auto<\/span> e :<\/span> container) std::<\/span>cout <<<\/span> e <<<\/span> ' '<\/span>;\n    std::<\/span>cout <<<\/span> "<\/span>\\n\\n<\/span>"<\/span>;\n}\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>vector myVec1{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};        \n    std::<\/span>vector myVec2{6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>};\n\n    std::<\/span>span<<\/span>int<\/span>><\/span> dynamicSpan(myVec1);          \/\/ (1)<\/span>\n    std::<\/span>span<<\/span>int<\/span>, 4<\/span>><\/span> staticSpan(myVec2);        \/\/ (2)<\/span>\n\n    printMe(dynamicSpan);\n    printMe(staticSpan);\n\n    \/\/ staticSpan = dynamicSpan;    ERROR        \/\/ (4)<\/span>\n    dynamicSpan =<\/span> staticSpan;                    \/\/ (5) <\/span>\n\n    printMe(staticSpan);                         \/\/ (6)<\/span>\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n}\n<\/pre><\/div>\n\n\n\n
dynamicSpan<\/code> (line 1) has a dynamic extent, while staticSpan<\/code> (line 2) has a static extent. Both std::span<\/code>s return their size in the printMe<\/code> function (line 3). A std::span <\/code>with static extent can be assigned to a std::span<\/code> with dynamic extent, but not vice versa. Line 4 would cause an error, but lines 5, and 6 are valid.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
There is one particular use case of std::span<\/code>.  A std::span<\/code> can be a constant range of modifiable elements.<\/p>\n\n\n\n
A Constant Range of Modifiable Elements<\/h2>\n\n\n\n
For simplicity, I name a std::vector<\/code> and a std::span range<\/code>. A std::vector<\/code> models a modifiable range of modifiable elements: std::vector<\/code>. When you declare this std::vector<\/code> as const<\/code>, it models a constant range of constant objects: const std::vector<\/code>. You cannot model a constant range of modifiable elements. This is where std::span<\/code> comes into play. A std::span<\/code> models a constant range of modifiable objects: std::span<\/code>. The following image emphasizes the variations of (constant\/modifiable) ranges and (constant\/modifiable) elements.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
\/\/ constRangeModifiableElements.cpp<\/span>\n\n#include <iostream><\/span>\n#include <span><\/span>\n#include <vector><\/span>\n\nvoid<\/span> printMe<\/span>(std::<\/span>span<<\/span>int<\/span>><\/span> container) {\n    \n    std::<\/span>cout <<<\/span> "container.size(): "<\/span> <<<\/span> container.size() <<<\/span> '\\n'<\/span>;  \n    for<\/span> (auto<\/span> e :<\/span> container) std::<\/span>cout <<<\/span> e <<<\/span> ' '<\/span>;\n    std::<\/span>cout <<<\/span> "<\/span>\\n\\n<\/span>"<\/span>;\n}\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>vector<<\/span>int<\/span>><\/span> origVec{1<\/span>, 2<\/span>, 2<\/span>, 4<\/span>, 5<\/span>};\n\n    \/\/ Modifiable range of modifiable elements<\/span>\n    std::<\/span>vector<<\/span>int<\/span>><\/span> dynamVec =<\/span> origVec;           \/\/ (1)<\/span>\n    dynamVec[2<\/span>] =<\/span> 3<\/span>;\n    dynamVec.push_back(6<\/span>);\n    printMe(dynamVec);\n\n    \/\/ Constant range of constant elements<\/span>\n    const<\/span> std::<\/span>vector<<\/span>int<\/span>><\/span> constVec =<\/span> origVec;     \/\/ (2)<\/span>\n    \/\/ constVec[2] = 3;        ERROR<\/span>\n    \/\/ constVec.push_back(6);  ERROR<\/span>\n    std::<\/span>span<<\/span>const<\/span> int<\/span>><\/span> constSpan(origVec);       \/\/ (3)<\/span>\n    \/\/ constSpan[2] = 3;       ERROR<\/span>\n\n    \/\/ Constant range of modifiable elements<\/span>\n    std::<\/span>span<<\/span>int<\/span>><\/span> dynamSpan{origVec};             \/\/ (4)<\/span>\n    dynamSpan[2<\/span>] =<\/span> 3<\/span>;\n    printMe(dynamSpan);\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre><\/div>\n\n\n\n
The vector dynamVec<\/code> (line 1) is a modifiable range of modifiable elements. This observation does not hold for the vector constVec<\/code> (line 2). Neither can constVec<\/code> change its elements nor its size. constSpan<\/code> (line 3) behaves accordingly. dynamSpan<\/code> (line 4) models the unique use case of a constant range of modifiable elements.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Finally, I want to mention two dangers you should know when using std::span<\/code>.<\/p>\n\n\n\n
Dangers of std::span<\/code><\/h2>\n\n\n\n
The typical issues of std::span<\/code> are twofold. First, a std::span<\/code> should not act on a temporary and second, the size of the underlying contiguous range of a std::span<\/code> should not be modified.<\/p>\n\n\n\n
A std::span<\/code> on a Temporary<\/h3>\n\n\n\n
A std::span<\/code> is never an owner. Therefore, a std::span<\/code> does not extend the lifetime of its underlying data. Consequently, a std::span should only operate on an lvalue. Using  std::span<\/code> on a temporary range is undefined behavior.<\/p>\n\n\n\n
\/\/ temporarySpan.cpp<\/span>\n\n#include <iostream><\/span>\n#include <span><\/span>\n#include <vector><\/span>\n\nstd::<\/span>vector<<\/span>int<\/span>><\/span> getVector() {                          \/\/ (2)<\/span>\n    return<\/span> {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\n}\n\nint<\/span> main() {\n\n     std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n    std::<\/span>vector<<\/span>int<\/span>><\/span> myVec{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};              \/\/ (1)<\/span>\n    std::<\/span>span<<\/span>int<\/span>, 5<\/span>><\/span> mySpan1{myVec};                  \n    std::<\/span>span<<\/span>int<\/span>, 5<\/span>><\/span> mySpan2{getVector().begin(), 5<\/span>};  \/\/ (3)<\/span>\n\n    for<\/span> (auto<\/span> v:<\/span> std::<\/span>span{myVec}) std::<\/span>cout <<<\/span> v <<<\/span> " "<\/span>;\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    for<\/span> (auto<\/span> v:<\/span> std::<\/span>span{getVector().begin(), 5<\/span>}) std::<\/span>cout <<<\/span> v <<<\/span> " "<\/span>;  \/\/ (4)<\/span>\n\n     std::<\/span>cout <<<\/span> "<\/span>\\n\\n<\/span>"<\/span>;\n    \n}\n<\/pre><\/div>\n\n\n\n
Using a std::span<\/code> with a static extent or a std::span<\/code> with a dynamic extent on the lvalue is fine. When I switch from the lvalue std::vector<\/code> in line 1 to a temporary std::vector<\/code>, given by the function getVector<\/code> (lines 2), the program has undefined behavior. Both lines 3 and 4 are not valid. Consequently, executing the program exposes the undefined behavior. The output of line 4 does not match with the std::vector<\/code>, generated by the function getVector().<\/code><\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Changing the Size of the Underlying Contiguous Range<\/h3>\n\n\n\n
When you change the size of the underlying contiguous range, the contiguous range may be reallocated, and the std::span<\/code> refers to stale data. <\/p>\n\n\n\n
std::<\/span>vector<<\/span>int<\/span>><\/span> myVec{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\n\nstd::<\/span>span<<\/span>int<\/span>><\/span> sp1{myVec};\n\nmyVec.push_back(6<\/span>);  \/\/ undefined behavior<\/span>\n<\/pre><\/div>\n\n\n\n
What’s Next?<\/h2>\n\n\n\n
In my next post, I dive once more in the formatting library of C++20.<\/p>\n","protected":false},"excerpt":{"rendered":"
A std::span represents an object that refers to a contiguous sequence of objects. Today, I want to write about its not-so-obvious features. 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 […]<\/p>\n","protected":false},"author":21,"featured_media":8904,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[456],"class_list":["post-8906","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20","tag-span"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/8906","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=8906"}],"version-history":[{"count":19,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/8906\/revisions"}],"predecessor-version":[{"id":8957,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/8906\/revisions\/8957"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/8904"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=8906"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=8906"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=8906"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}