std::span

在标头 `<span>` 定义
template< class T, std::size_t Extent = std::dynamic_extent > class span;		(C++20 起)

类模板 span 所描述的对象可以指代首元素在零位置的连续序列。 span 能拥有静态长度，该情况下序列中的元素数已知并在编译期以模版参数 Extent 指定，否则默认拥有动态长度。

如果span 是动态长度，那它的典型实现会有两个成员：指向 T 的指针和长度。如果是静态长度可能只有一个成员：指向 T 的指针。

std::span 的每个特化均为可平凡复制 (TriviallyCopyable) 类型。

(C++23 起)

模板形参

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) 兼老式连续迭代器 (LegacyContiguousIterator) ，其 `value_type` 为 `value_type`
`reverse_iterator`	std::reverse_iterator<iterator>
`const_reverse_iterator`	std::reverse_iterator<const_iterator>

注意：若 T 无 const 限定则 iterator 为可变迭代器。

容器 (Container) 的迭代器类型上的所有要求亦应用于 span 的 iterator 类型。

成员常量

static constexpr std::size_t extent = Extent;

成员函数

(构造函数)	构造 `span` (公开成员函数)
operator=	赋值 `span` (公开成员函数)
迭代器
begin (C++20)	返回指向起始的迭代器 (公开成员函数)
end (C++20)	返回指向末尾的迭代器 (公开成员函数)
rbegin (C++20)	返回指向起始的逆向迭代器 (公开成员函数)
rend (C++20)	返回指向末尾的逆向迭代器 (公开成员函数)
元素访问
front (C++20)	访问第一个元素 (公开成员函数)
back (C++20)	访问最后一个元素 (公开成员函数)
operator[]	访问序列的元素 (公开成员函数)
data	返回指向元素序列起始的指针 (公开成员函数)
观察器
size	返回序列中的元素数 (公开成员函数)
size_bytes	返回以字节表示的序列大小 (公开成员函数)
empty	检查序列是否为空 (公开成员函数)
子视图
first	获得由序列首 N 个元素组成的子段 (公开成员函数)
last	获得由序列末 N 个元素组成的子段 (公开成员函数)
subspan	获得子段 (公开成员函数)

非成员函数

as_bytesas_writable_bytes

转换 span 为对其底层字节的视图
(函数模板)

非成员常量

dynamic_extent

(C++20)

size_t 类型常量，指明 span 拥有动态长度
(常量)

辅助模板

template<class T, std::size_t Extent> inline constexpr bool ranges::enable_borrowed_range<std::span<T, Extent>> = true;

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

template<class T, std::size_t Extent> inline constexpr bool ranges::enable_view<std::span<T, Extent>> = true;

std::ranges::enable_view 的此特化使零或动态长度的 span 满足 view 。

推导指引

注解

即使在 C++23 中引入的正式要求前，所有既存实现中 std::span 的特化已经为可平凡复制类型。

功能特性测试宏	值	标准	备注
`__cpp_lib_span`	202002L	(C++20)	`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> [[nodiscard]]
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> [[nodiscard]]
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> [[nodiscard]]
constexpr bool contains(std::span<T,N> span, std::span<T,M> sub) {
    return std::search(span.begin(), span.end(), sub.begin(), sub.end()) != span.end();
//  return std::ranges::search(span, sub).begin() != span.end();
}
 
void print(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 };
 
    for (std::size_t offset{}; ; ++offset) {
        constexpr std::size_t width{6};
        auto s = slide(std::span{a}, offset, width);
        if (s.empty())
            break;
        print(s);
    }
 
    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++ 标准。

缺陷报告	应用于	出版时的行为	正确行为
P2325R3	C++20	非零静态长度的 `span` 不是 `view`	`view` 不要求 `default_initializable` 故它们是

参阅

initializer_list (C++11)	在列表初始化中创建临时数组然后引用它 (类模板)
basic_string_view (C++17)	只读的字符串视图 (类模板)
ranges::subrange (C++20)	将迭代器/哨位对结合为一个 `view` (类模板)

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
技术规范
符号索引
外部库

顺序容器
array (C++11)
vector
deque
forward_list (C++11)
list
关联容器
set
multiset
map
multimap
无序关联容器
unordered_set (C++11)
unordered_multiset (C++11)
unordered_map (C++11)
unordered_multimap (C++11)
容器适配器
stack
queue
priority_queue
flat_set (C++23)
flat_multiset (C++23)
flat_map (C++23)
flat_multimap (C++23)
视图
span (C++20)
mdspan (C++23)
迭代器失效
成员函数表格
非成员函数表格

成员函数
span::span
span::operator=
元素访问
span::front
span::back
span::operator[]
span::data
迭代器
span::begin
span::end
span::rbegin
span::rend
观察器
span::empty
span::size
span::size_bytes
子视图
span::first
span::last
span::subspan
非成员函数
as_bytesas_writable_bytes
get
非成员常量
dynamic_extent
推导指引