命名空间
变体
操作

std::span

来自 cppreference.cn
< cpp‎ | 容器
 
C++
 
容器库
 
std::span
 
在头文件 <span> 中定义
模板<

    类 T,
    std::size_t Extent = std::dynamic_extent

> 类 span;
 (C++20 起)

类模板 span 描述了一个对象，该对象可以引用一个连续的对象序列，序列的第一个元素位于位置零。span 可以具有静态范围，在这种情况下，序列中的元素数量在编译时已知并编码在类型中，或者具有动态范围。

对于一个 span s，当某个操作使范围 [s.data(), s.data() + s.size()) 内的指针失效时，指向 s 元素的指针、迭代器和引用也会失效。

std::span 的每个特化都是一个 TriviallyCopyable 类型。

 (C++23 起)

典型的实现持有指向 T 的指针，如果范围是动态的，实现还会持有一个大小。

目录

[编辑] 模板参数

T - 元素类型；必须是完整的对象类型，且不是抽象类类型
Extent - 序列中的元素数量，如果是动态的，则为 std::dynamic_extent

[编辑] 成员类型

成员类型 定义
element_type T
value_type std::remove_cv_t<T>
size_type std::size_t
difference_type std::ptrdiff_t
pointer T*
const_pointer const T*
reference T&
const_reference const T&
iterator 实现定义的 LegacyRandomAccessIterator、ConstexprIterator 和 contiguous_iterator，其 value_type 为 value_type
const_iterator (C++23 起) std::const_iterator<iterator>
reverse_iterator std::reverse_iterator<iterator>
const_reverse_iterator (C++23 起) std::const_iterator<reverse_iterator>

注意：如果 T 没有 const 限定，则 iterator 是可变迭代器。

对 Container 的迭代器类型的所有要求也适用于 span 的 iterator 类型。

[编辑] 成员常量

名称 值
constexpr std::size_t extent
[静态]
 Extent
(public static 成员常量)

[编辑] 成员函数

 构造一个 span
(公共成员函数) [编辑]
 赋值一个 span
(公共成员函数) [编辑]
(析构函数)
(隐式声明)
 销毁一个 span
(公开成员函数)
迭代器
(C++23 起)
 返回指向起始的迭代器
(公共成员函数) [编辑]
(C++23 起)
 返回指向末尾的迭代器
(公共成员函数) [编辑]
(C++23 起)
 返回指向起始的逆向迭代器
(公共成员函数) [编辑]
(C++23 起)
 返回指向末尾的逆向迭代器
(公共成员函数) [编辑]
元素访问
 访问第一个元素
(公共成员函数) [编辑]
 访问最后一个元素
(公共成员函数) [编辑]
(C++26)
 访问指定的元素，带边界检查
(公共成员函数) [编辑]
 访问指定的元素
(公共成员函数) [编辑]
 直接访问底层连续存储
(公共成员函数) [编辑]
观察器
 返回元素数量
(公共成员函数) [编辑]
 返回序列的字节大小
(公共成员函数) [编辑]
 检查序列是否为空
(公共成员函数) [编辑]
子视图
 获取由序列前 N 个元素组成的子 span
(公共成员函数) [编辑]
 获取由序列后 N 个元素组成的子 span
(公共成员函数) [编辑]
 获取一个子 span
(公共成员函数) [编辑]

[编辑] 非成员函数

(C++20)
 将 `span` 转换为其底层字节的视图
(函数模板) [编辑]

[编辑] 非成员常量

(C++20)
 类型为 std::size_t 的常量，表示 span 具有动态范围
(常量) [编辑]

[编辑] 辅助模板

模板< 类 T, std::size_t Extent >
constexpr bool ranges::enable_borrowed_range<std::span<T, Extent>> = true;
 (C++20 起)

此 ranges::enable_borrowed_range 的特化使得 span 满足 borrowed_range。

模板< 类 T, std::size_t Extent >
constexpr bool ranges::enable_view<std::span<T, Extent>> = true;
 (C++20 起)

此 ranges::enable_view 的特化使得 span 满足 view。

[编辑] 推导指南

[编辑] 备注

std::span 的特化在所有现有实现中已经都是平凡可复制类型，甚至在 C++23 引入正式要求之前。

特性测试宏 值 标准 特性
__cpp_lib_span 202002L (C++20) std::span
202311L (C++26) std::span::at
__cpp_lib_span_initializer_list 202311L (C++26) 从 std::initializer_list 构造 std::span

[编辑] 示例

此示例使用 std::span 在连续范围内实现一些算法。

运行此代码
#include <algorithm>
#include <cstddef>
#include <iostream>
#include <span>
 
template<class T, std::size_t N>
[[nodiscard]]
constexpr auto slide(std::span<T, N> s, std::size_t offset, std::size_t width)
{
    return s.subspan(offset, offset + width <= s.size() ? width : 0U);
}
 
template<class T, std::size_t N, std::size_t M>
constexpr bool starts_with(std::span<T, N> data, std::span<T, M> prefix)
{
    return data.size() >= prefix.size()
        && std::equal(prefix.begin(), prefix.end(), data.begin());
}
 
template<class T, std::size_t N, std::size_t M>
constexpr bool ends_with(std::span<T, N> data, std::span<T, M> suffix)
{
    return data.size() >= suffix.size()
        && std::equal(data.end() - suffix.size(), data.end(),
                      suffix.end() - suffix.size());
}
 
template<class T, std::size_t N, std::size_t M>
constexpr bool contains(std::span<T, N> span, std::span<T, M> sub)
{
    return std::ranges::search(span, sub).begin() != span.end();
}
 
void println(const auto& seq)
{
    for (const auto& elem : seq)
        std::cout << elem << ' ';
    std::cout << '\n';
}
 
int main()
{
    constexpr int a[]{0, 1, 2, 3, 4, 5, 6, 7, 8};
    constexpr int b[]{8, 7, 6};
    constexpr static std::size_t width{6};
 
    for (std::size_t offset{}; ; ++offset)
        if (auto s = slide(std::span{a}, offset, width); !s.empty())
            println(s);
        else
            break;
 
    static_assert(""
        && starts_with(std::span{a}, std::span{a, 4})
        && starts_with(std::span{a + 1, 4}, std::span{a + 1, 3})
        && !starts_with(std::span{a}, std::span{b})
        && !starts_with(std::span{a, 8}, std::span{a + 1, 3})
        && ends_with(std::span{a}, std::span{a + 6, 3})
        && !ends_with(std::span{a}, std::span{a + 6, 2})
        && contains(std::span{a}, std::span{a + 1, 4})
        && !contains(std::span{a, 8}, std::span{a, 9})
    );
}

输出

0 1 2 3 4 5
1 2 3 4 5 6
2 3 4 5 6 7
3 4 5 6 7 8

[编辑] 缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 发布时的行为 正确的行为
LWG 3203 C++20 不清楚何时 span 元素的指针、迭代器和
引用会失效		 已明确
LWG 3903 C++20 span 的析构函数声明不必要 移除了声明
P2325R3 C++20 非零静态范围的 span 不是一个 view 任何 span 都是一个 view

[编辑] 另请参见

(C++23)
 一个多维非拥有数组视图
(类模板) [编辑]
(C++20)
 将迭代器-哨兵对组合成一个 view
(类模板) [编辑]
(C++11)
 引用在列表初始化中创建的临时数组
(类模板) [编辑]
(C++17)
 只读字符串视图
(类模板) [编辑]
取自“https://cppreference.cn/mwiki/index.php?title=cpp/container/span&oldid=176449”