为何std::span双指针/迭代器构造函数未限制元素范围？

问题代码 #

#include <iostream>
#include <span>
#include <string>
#include <string_view>
#include <vector>

namespace {
template <typename TSpan>
auto createSubSpan1(TSpan &, typename TSpan::iterator start,
                    typename TSpan::iterator stop) {
    static_assert(!std::is_convertible_v<typename TSpan::iterator, std::size_t>);
    return TSpan{start, stop};
}

template <typename TSpan>
auto createSubSpan2(TSpan &span, typename TSpan::iterator start,
                    typename TSpan::iterator stop) {
    auto startOffset = std::distance(span.begin(), start);
    auto stopOffset = std::distance(span.begin(), stop);
    std::cout << startOffset << "-" << stopOffset << std::endl;
    static_assert(!std::is_convertible_v<decltype(span.data() + startOffset), std::size_t>);
    return TSpan{span.data() + startOffset, span.data() + stopOffset};
}

template <typename TSpan>
auto createSubSpan3(TSpan &span, typename TSpan::iterator start,
                    typename TSpan::iterator stop) {
    return span.subspan(static_cast<std::size_t>(std::distance(span.begin(), start)),
                        static_cast<std::size_t>(std::distance(start, stop)));
}

template <typename TSpan>
auto printSpan(std::string_view header, TSpan span) {
    std::cout << header << std::endl;
    for (const auto &element : span) std::cout << "	" << element << std::endl;
}
}  // namespace

int main() {
    int a[]{0, 1, 2, 3, 4, 5, 6, 7, 8};
    auto span = std::span{a};

    std::vector<int> vector{11, 12, 13};

    auto beginIt = span.begin();
    auto endIt = std::move(vector.begin(), vector.end(), beginIt);

    printSpan("incorrect (iterator)", createSubSpan1(span, beginIt, endIt));
    printSpan("incorrect (pointer)", createSubSpan2(span, beginIt, endIt));
    printSpan("correct", createSubSpan3(span, beginIt, endIt));
}

输出结果 #

incorrect (iterator)
    11
    12
    13
    3
    4
    5
    6
    7
    8
0-3
incorrect (pointer)
    11
    12
    13
    3
    4
    5
    6
    7
    8
correct
    11
    12
    13

问题原因 #

核心问题出在固定extent的std::span的构造规则上：

1. 范围构造函数的explicit属性
   你使用的std::span是固定大小的（从9元素数组初始化，extent为9），此时标准规定对应的范围构造函数是explicit的。而你采用列表初始化TSpan{start, stop}的方式无法调用explicit构造函数，编译器会 fallback 到其他初始化逻辑，最终构造出不符合预期的span。

2. 固定extent的前置条件
   即便改用直接初始化TSpan(start, stop)调用该构造函数，也会触发未定义行为：标准要求当extent不是std::dynamic_extent时，必须保证std::distance(first, last)等于extent的值（即9）。你传入的范围大小是3，不满足该条件，编译器可以生成任意行为，比如构造出从start开始、覆盖整个原数组的span。

3. subspan方法的正确逻辑
   span.subspan()方法的设计是创建一个新的span，其范围由起始偏移和长度决定，不受原span固定extent的限制（只要参数在原span的合法范围内）。它会根据传入的长度生成对应大小的span，因此能正确返回包含3个元素的结果。

解决方法 #

如果需要从迭代器范围创建动态大小的span，显式指定std::span<int, std::dynamic_extent>类型，此时范围构造函数不是explicit的，且不需要匹配固定长度：

// 修改main中的span定义为动态extent
auto span = std::span<int, std::dynamic_extent>{a};

此时createSubSpan1和createSubSpan2就能正确调用范围构造函数，生成包含3个元素的span。

内容的提问来源于stack exchange，提问作者JVApen