命名空间
变体
操作

std::span

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

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

> class 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 是可变迭代器。

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

[编辑] 成员常量

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

[编辑] 成员函数

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

[编辑] 非成员函数

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

[编辑] 非成员常量

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

[编辑] 辅助模板

template< class 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。

template< class 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 中引入正式要求之前也是如此。

特性测试 宏 值 Std 特性
__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++ 标准。

DR 应用于 发布的行为 正确行为
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"