(C++17) | ||||
| Sequence | ||||
(C++11) | ||||
(C++26) | ||||
(C++26) | ||||
(C++11) | ||||
| Associative | ||||
| Unordered associative | ||||
(C++11) | ||||
(C++11) | ||||
(C++11) | ||||
(C++11) | ||||
| Adaptors | ||||
(C++23) | ||||
(C++23) | ||||
(C++23) | ||||
(C++23) | ||||
| Views | ||||
(C++20) | ||||
(C++23) | ||||
| Tables | ||||
| Iterator invalidation | ||||
| Member function table | ||||
| Non-member function table |
| Member functions | ||||
span::operator= | ||||
| Element access | ||||
(C++26) | ||||
| Iterators | ||||
(C++23) | ||||
(C++23) | ||||
(C++23) | ||||
(C++23) | ||||
| Observers | ||||
| Subviews | ||||
| Non-member functions | ||||
| Non-member constant | ||||
| Deduction guides |
constexpr span& operator=(const span& other)noexcept=default; | (since C++20) | |
Assignsother to*this. This defaulted assignment operator performs a shallow copy of the data pointer and the size, i.e., after a call to this function,data()== other.data() andsize()== other.size().
Contents |
| other | - | another span to copy from |
*this
#include <algorithm>#include <array>#include <cassert>#include <cstddef>#include <iostream>#include <span>#include <string_view> void print(std::string_view info="",std::span<constint> span={},std::size_t extent=0,std::size_t size_of=0){if(span.empty()){std::cout<< info<<'\n';return;} std::cout<< info<<'['<< span.size()<<"] {"; std::ranges::for_each(span,[](constint x){std::cout<<' '<< x;});std::cout<<" }"; if(extent){std::cout<<" extent = ";if(extent==std::dynamic_extent)std::cout<<"dynamic";elsestd::cout<< extent;} if(size_of)std::cout<<", sizeof = "<< size_of; std::cout<<'\n';} int main(){std::array<int,6> a1;std::array<int,6> a2; a1.fill(3); a2.fill(4); auto s1=std::span(a1);auto s2=std::span(a2); print("s1", s1, s1.extent, sizeof(s1)); print("s2", s2, s2.extent, sizeof(s2)); // Check that assignment performs a shallow copy. s1= s2;(s1.data()== s2.data()&& s1.size()== s2.size())? print("s1 = s2; is a shallow copy!"): print("s1 = s2; is a deep copy!"); print("s1", s1); print("Fill s1 with 5:"); std::ranges::fill(s1,5);// s2 is also 'updated' since s1 and s2 point to the same dataassert(std::ranges::equal(s1, s2)); print("s1", s1); print("s2", s2); print(); int a3[]{1,2,3,4};int a4[]{2,3,4,5};int a5[]{3,4,5}; std::span<int,std::dynamic_extent> dynamic_1{a3};std::span<int,std::dynamic_extent> dynamic_2{a4,3};std::span<int,4> static_1{a3};std::span<int,4> static_2{a4};std::span<int,3> static_3{a5}; print("dynamic_1", dynamic_1, dynamic_1.extent, sizeof(dynamic_1)); print("dynamic_2", dynamic_2, dynamic_2.extent, sizeof(dynamic_2)); print("static_1", static_1, static_1.extent, sizeof(static_1)); print("static_2", static_2, static_2.extent, sizeof(static_2)); print("static_3", static_3, static_3.extent, sizeof(static_3)); dynamic_1= dynamic_2;// OK dynamic_1= static_1;// OK// static_1 = dynamic_1; // ERROR: no match for ‘operator=’ static_1= static_2;// OK: same extents = 4// static_1 = static_3; // ERROR: different extents: 4 and 3}
Output:
s1[6] { 3 3 3 3 3 3 } extent = 6, sizeof = 8s2[6] { 4 4 4 4 4 4 } extent = 6, sizeof = 8s1 = s2; is a shallow copy!s1[6] { 4 4 4 4 4 4 }Fill s1 with 5:s1[6] { 5 5 5 5 5 5 }s2[6] { 5 5 5 5 5 5 } dynamic_1[4] { 1 2 3 4 } extent = dynamic, sizeof = 16dynamic_2[3] { 2 3 4 } extent = dynamic, sizeof = 16static_1[4] { 1 2 3 4 } extent = 4, sizeof = 8static_2[4] { 2 3 4 5 } extent = 4, sizeof = 8static_3[3] { 3 4 5 } extent = 3, sizeof = 8 constructs thespan(public member function)[edit] | |
| direct access to the underlying contiguous storage (public member function)[edit] | |
| returns the number of elements (public member function)[edit] |