# std::span<T,Extent>::operator=

< cpp‎ | container‎ | span

constexpr span& operator=( const span& other ) noexcept = default; |  |

赋值 `other` 给 *this 。此默认化的赋值运算符进行数据指针和大小的浅复制，即调用此函数后， data() == other.data() 且 size() == other.size() 。

### 参数

other | - | 要复制的另一 span

### 返回值

*this 。

### 示例

    #include <algorithm>
    #include <array>
    #include <cassert>
    #include <cstddef>
    #include <iostream>
    #include <span>
    #include <string_view>

    void print(std::string_view info = "", std::span<const int> span = {},
               std::size_t extent = 0, std::size_t size_of = 0) {
        if (span.size() == 0) {
            std::cout << info << '\n';
            return;
        }
        std::cout << info << '[' << span.size() << "] {";
        std::ranges::for_each(span, [](const int x) { std::cout << ' ' << x; });
        std::cout << " }";
        if (extent != 0) {
            std::cout << " extent = ";
            if (extent == std::dynamic_extent)
                std::cout << "dynamic";
            else
                std::cout << extent;
        }
        if (size_of != 0) {
            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));

        // 检查赋值是否进行浅复制
        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 亦被“更新”因为 s1 与 s2 引用同一数据
        assert(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; // 错误：无匹配的 ‘operator=’
        static_1  = static_2;  // OK ：相同长度 = 4
     // static_1  = static_3;  // 错误：不同长度： 4 与 3
    }

输出：

    s1[6] { 3 3 3 3 3 3 } extent = 6, sizeof = 8
    s2[6] { 4 4 4 4 4 4 } extent = 6, sizeof = 8
    s1 = 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 = 16
    dynamic_2[3] { 2 3 4 } extent = dynamic, sizeof = 16
    static_1[4] { 1 2 3 4 } extent = 4, sizeof = 8
    static_2[4] { 2 3 4 5 } extent = 4, sizeof = 8
    static_3[3] { 3 4 5 } extent = 3, sizeof = 8

### 参阅

(构造函数) | 构造 `span` (公开成员函数)
data | 返回指向元素序列起始的指针 (公开成员函数)
size | 返回序列中的元素数 (公开成员函数)