当前位置：首页 > article >正文

std::span

article 2025/3/15 8:53:04

C++20中引入了std::span<>类,用来引用元素序列而不需要分配内容。其中std::span<>类模板就是其中之一。要求元素存储在连续的内容中，std::span<>类为子序列提供了最佳性能。

std::span<>类型引用的对象元素必须是一个接一个的存储在连续的存储中，并且使用时具有只读或者写的访问。

实际上，std::span就像指向一系列元素的原始指针并结合一个元素数量的大小数字。允许我们处理像数组这样的元素。然而，由于其引用语义（尤其是关于const正确性），特殊规则被使用。

使用std::span及廉价又快(应该始终按值传递它).然而，它也可能这很危险，因为与原始指针一样，程序员需要确保在使用span时所引用的元素序列仍然有效。此外，span支持写访问可能会导致破坏const正确性的情况（或者至少不按您预期的方式工作）。

9.1 使用span

当你声明一个 span 时，你可以选择指定一个固定数量的元素，或者保留元素数量的开放性，使得 span 所引用的元素数量可以改变。

9.1.1 固定和动态长度(Extent)

当你声明span的时候，可以选择指定一个固定数量的元素或者也可以保留该数量，直到明确span所指的元素的数量。

具有指定固定元素数量的 span 被称为具有固定长度(extent)的 span。它可以通过指定元素类型和大小作为模板参数来声明，或者通过使用数组（原始数组或 std::array<>）的迭代器和大小进行初始化来声明。

int a5[5] = {1, 2, 3, 4, 5};

std::array arr5{1, 2, 3, 4, 5};

std::vector vec{1, 2, 3, 4, 5, 6, 7, 8};

std::span sp1 = a5; // span with fixed extent of 5 elements

std::span sp2{arr5}; // span with fixed extent of 5 elements

std::span<int, 5> sp3 = arr5; // span with fixed extent of 5 elements

std::span<int, 3> sp4{vec}; // span with fixed extent of 3 elements

std::span<int, 4> sp5{vec.data(), 4}; // span with fixed extent of 4 elements

std::span sp6 = sp1; // span with fixed extent of 5 elements

对于这样的 span，成员函数 size() 总是返回作为类型的一部分指定的大小。除非长度(extent)为 0，否则不能调用默认构造函数。

当 span 的元素数量在其生命周期内不稳定时，称为具有动态长度(extent)的 span。元素数量取决于 span 所引用的元素序列，并且可能由于分配新的基础范围（没有其他方式可以改变元素数量）而发生变化。例如：

int a5[5] = {1, 2, 3, 4, 5};

std::array arr5{1, 2, 3, 4, 5};

std::vector vec{1, 2, 3, 4, 5, 6, 7, 8};

std::span<int> sp1; // span with dynamic extent (initially 0 elements)

std::span sp2{a5, 3}; // span with dynamic extent (initially 3 elements)

std::span<int> sp3{arr5}; // span with dynamic extent (initially 5 elements)

std::span sp4{vec}; // span with dynamic extent (initially 8 elements)

std::span sp5{arr5.data(), 3}; // span with dynamic extent (initially 3 elements)

std::span sp6{a5+1, 3}; // span with dynamic extent (initially 3 elements)

请注意，由程序员来确保 span 引用的范围是有效的，并且具有足够的元素。

对于这两种情况，让我们看一些完整的示例。

9.1.2 使用动态范围span的示例

这里介绍一个动态长度(extent)的第一个例子：

#include <iostream>
#include <string>
#include <vector>
#include <ranges>
#include <algorithm>
#include <span>

template<typename T, std::size_t Sz>
void printSpan(std::span<T, Sz> sp)
{
  for (const auto& elem : sp) {
    std::cout << '"' << elem << "\" ";
  }
  std::cout << '\n';
}

int main()
{
  std::vector<std::string> vec{"New York", "Tokyo", "Rio", "Berlin", "Sydney"};

  // define view to first 3 elements:
  std::span<const std::string> sp{vec.data(), 3};
  std::cout << "first 3:                   ";
  printSpan(sp);

  // sort elements in the referenced vector:
  std::ranges::sort(vec);
  std::cout << "first 3 after sort():      ";
  printSpan(sp);

  // insert a new element:
  // - must reassign the internal array of the vector if it reallocated new memory
  auto oldCapa = vec.capacity();
  vec.push_back("Cairo");
  if (oldCapa != vec.capacity()) {
    sp = std::span{vec.data(), 3};
  }
  std::cout << "first 3 after push_back(): ";
  printSpan(sp);

  // let span refer to the vector as a whole:
  sp = vec;
  std::cout << "all:    ";
  printSpan(sp);  

  // let span refer to the last five elements:
  sp = std::span{vec.end()-5, vec.end()};
  std::cout << "last 5: ";
  printSpan(sp);

  // let span refer to the last four elements:
  sp = std::span{vec}.last(4);
  std::cout << "last 4: ";
  printSpan(sp);
}

程序输出：

first 3: "New York" "Tokyo" "Rio"

first 3 after sort(): "Berlin" "New York" "Rio"

first 3 after push_back(): "Berlin" "New York" "Rio"

all: "Berlin" "New York" "Rio" "Sydney" "Tokyo" "Cairo"

last 5: "New York" "Rio" "Sydney" "Tokyo" "Cairo"

last 4: "Rio" "Sydney" "Tokyo" "Cairo"

介绍下这部分代码：

定义一个span

在 main() 函数中，我们首先使用vector的前三个元素来初始化一个包含三个const string的 span：

std::vector<std::string> vec{"New York", "Rio", "Tokyo", "Berlin", "Sydney"};

std::span<const std::string, 3> sp3{vec.begin(), 3};

在初始化时，我们传递了序列的起始位置和元素数量。在这种情况下，我们引用了 vec 的前三个元素。

关于这个声明有很多需要注意的事项：

由程序员负责确保元素的数量与 span 的长度匹配，并且元素是有效的。如果向量没有足够的元素，行为是未定义的：

std::span<const std::string, 3> sp3{vec.begin(), 10}; // undefined behavior

~~永远不要用（返回的）临时值初始化~~~~span~~~~，因为span引用的对象在赋值后就被销毁了：~~

~~std::span<int, 3> sp3a = std::array{1, 2, 3}; // fatal runtime ERROR~~

~~std::span<int, 3> sp3b = returnArray(); // fatal runtime ERROR~~

需要指出的是通过指定span元素为const string类型的，我们无法通过span修改他们的值。注意，声明span为const span的话并没有提供只读访问给引用元素：

std::span<const std::string, 3> sp3{vec.begin(), 3}; // elements cannot be modified by sp3

const std::span<std::string, 3> sp3{vec.begin(), 3}; // elements can be modified

在 span 的元素类型与引用元素的类型不同时，看起来好像可以使用任何转换为基础元素类型的类型。然而，这是不正确的。你只能添加诸如 const 之类的限定符：

std::vector<int> vec{ ... };

std::span<long, 3> sp3{vec.begin(), 3}; // ERROR

传递和输出span

下一步，输出span，传递span到一个泛型print函数:

printSpan(sp3);

该打印函数可以处理任何的span(元素的输出运算符必须得定义了)

template<typename T, std::size_t Sz>
void printSpan(std::span<T, Sz> sp)

{

    for (const auto& elem : sp) 
    {
        std::cout << '"' << elem << "\" ";
    }

    std::cout << '\n';

}

你可能会感到惊讶，即使函数模板 printSpan<>() 具有用于 span 大小的非类型模板参数，它也可以被调用。这是因为 std::span<T> 是一个具有伪大小 std::dynamic_extent 的 span 的快捷方式。

std::span<int> sp; // equivalent to std::span<int, std::dynamic_extent>

实际上，类模板std::span被声明为如下：

namespace std {

template<typename ElementType, size_t Extent = dynamic_extent>

class span {

...

};

}

这使得程序员可以提供适用于具有固定长度(extent)和具有动态长度(extent)的 span 的通用代码，例如 printSpan<>()。当使用具有固定长度(extent)的 span 调用 printSpan<>() 时，长度(extent)会作为模板参数传递：

std::span<int, 5> sp{ ... };

printSpan(sp); // calls printSpan<int, 5>(sp)

正如你所看到的，span 是按值传递的。这是推荐的传递 span 的方式，因为它们在内部只是一个指针和一个大小，所以复制起来很廉价。

在 printSpan 函数内部，我们使用range-based循环来迭代 span 的元素。这是可能的，因为 span 提供了以 begin() 和 end() 支持的迭代器。

然而，需要注意的是：无论我们是按值传递还是按 const 引用传递 span，在函数内部我们仍然可以修改元素，只要它们没有被声明为 const(std::span<const std::string, 3> sp3{vec.begin(), 3};)。这就是为什么通常将 span 的元素声明为 const 是有意义的。

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

template<typename T, std::size_t Sz>
//void printSpan(const std::span<T, Sz>& sp)//跟下面这行代码一样都可以修改sp的值
void printSpan(std::span<T, Sz> sp)
{
	for (auto& elem : sp) 
	{
	    std::cout << '"' << elem << "\" ";
        elem += "X";
    }
    std::cout << '\n';
}

int main()
{
	std::vector<std::string> vec{"New York", "Tokyo", "Rio", "Berlin", "Sydney"};
	std::span<std::string, 3> sp3{vec.begin(), 3};
	std::cout << "first 3: ";
	printSpan(sp3);
	
	printSpan(sp3);
}

处理引用语义

接下来，我们对span所引用的元素进行排序（我们在这里使用了新的std::ranges::sort，它将整个容器作为参数):

std::ranges::sort(vec);

std::vector<std::string> vec{"New York", "Rio", ... }; // elements not const


std::span<std::string, 3> span3{vec.begin(), 3};   //

std::ranges::sort(span3); // sort first 3 elements only


std::span<const std::string, 3> span4{vec.begin(), 3};

std::ranges::sort(span4); // error: no match for call to ‘(const std::ranges::__sort_fn) (std::span, 3>&)

由于span具有引用语义，排序同样也影响了span:进行了同样的排序。如果我们没有给span使用const给元素类型(std::span<const Type, Size>)，也可以使用span调用sort排序。

#include <iostream>
#include <string>
#include <vector>
#include <span>
#include <ranges>
#include <algorithm>
template<typename T, std::size_t Sz>
void printSpan(const std::span<T, Sz>& sp)
{
	for (auto& elem : sp) 
	{
	    std::cout << '"' << elem << "\" ";
        //elem += "X";
    }
    std::cout << '\n';
}

int main()
{
	std::vector<std::string> vec{"New York", "Tokyo", "Rio", "Berlin", "Sydney"};
	std::span<std::string, 3> sp3{vec.begin(), 3};   //

	printSpan(sp3);
	std::ranges::sort(sp3); // sort first 3 elements only
	printSpan(sp3);
    for(const auto& s : vec)
    {
        std::cout << '"' << s << "\" ";
    }
}

引用语义意味着在使用 span 时必须小心，这在示例中展示了下面的语句。在这里，我们向包含 span 所引用的元素的向量中插入一个新元素。由于 span 的引用语义，这是我们必须非常小心的事情，因为如果vector重新分配内存，它将使所有迭代器和指向其元素的指针失效。因此，重新分配还会使引用vector元素的 span 失效。span 引用的元素已经不存在了。

因此，我们在插入之前和之后双重检查容量（已分配内存的最大元素数量）。如果容量发生变化，我们将重新初始化 span，引用新内存中的前三个元素：

auto oldCapa = vec.capacity();

vec.push_back("Cairo");

if (oldCapa != vec.capacity())

{

sp = std::span{vec.data(), 3};

}

我们之所以可以进行这种重新初始化，是因为 span 本身不是 const。

下一步，我们插入了一个新的元素到span引用的vector中。由于span引用语义，这里就要格外小心了。因为如果vector分配新的内存将使所有迭代器和指向其元素的指针无效。因此，重新分配也会使引用给vector的span失效，span指向的是已经不存在的元素。

因此，我们再次检查vector capacity（内存的最大元素数已分配）。如果它改变了，我们重新初始化span以引用前三个新内存中的元素：

auto oldCapa = vec.capacity();

vec.push_back("Cairo");

if (oldCapa != vec.capacity())

{

span3 = std::span<std::string, 3>{vec.begin(), 3};

}

我们只能执行此重新初始化，因为span本身不是常量(不是const std::span<std::string, 3>)。

赋值容器给span

我们将整个vector分配给span，并将其打印出来：

std::span<const std::string> sp{vec.begin(), 3};

printSpan(sp); // 打印vector的前3个元素

sp = vec;

printSpan(sp); // 打印vector的所有元素

在这里，你可以看到对具有动态长度(extent)的 span 的赋值操作可以改变元素的数量。

Span 可以接受任何类型的容器或range，只要容器以连续的内存存放元素，并且提供通过成员函数 data() 访问元素。

然而，由于模板类型推导的限制，你不能将这样的容器传递给期望一个 span 的函数。你必须明确指定要将向量转换为 span：

printSpan(vec); // ERROR: template type deduction doesn’t work here

printSpan(std::span{vec}); // OK

分配不同的子序列

通常情况下，span 的赋值运算符允许我们分配另一个元素序列。示例中使用了这个功能来后续引用向量中的最后三个元素：

std::span<const std::string> sp{vec.data(), 3};

...

// assign view to last five elements:

sp = std::span{vec.end()-5, vec.end()};

在这里，你可以看到我们可以使用两个迭代器来指定引用的序列，这两个迭代器定义了序列的起始和结束，作为一个半开区间（包含起始值，不包含结束值）。要求是起始和结束都满足 std::sized_sentinel_for 概念，以便构造函数可以计算差异。

然而，正如下面的语句所示，也可以使用 span 的成员函数来分配最后的 n 个元素：

std::vector<std::string> vec{"New York", "Tokyo", "Rio", "Berlin", "Sydney"};

std::span<const std::string> sp{vec.data(), 3};

...

// assign view to last four elements:

sp = std::span{vec}.last(4);

Span 是唯一提供一种方式来获取range中间或末尾序列的视图。只要元素类型匹配，你可以传递任何其他类型的元素序列。例如：

std::vector<std::string> vec{"New York", "Tokyo", "Rio", "Berlin", "Sydney"};

std::span<const std::string> sp{vec.begin(), 3};

...

std::array<std::string, 3> arr{"Tick", "Trick", "Track"};

sp = arr; // OK

但是要注意，span 不支持元素类型的隐式类型转换（除了添加 const）。例如，以下代码无法编译通过：

std::span<const std::string> sp{vec.begin(), 3};

...

std::array arr{"Tick", "Trick", "Track"}; // deduces std::array<const char*, 3>

sp = arr; // ERROR: different element types

9.1.3 使用非const元素Span的示例

在初始化 span 时，我们可以使用类模板参数推导，以便推断元素的类型（和长度）

std::span sp{vec.begin(), 3}; // deduces: std::span<std::string>

然后，span 声明元素的类型为底层range的元素类型，这意味着你甚至可以修改底层range的值，前提是底层range没有将其元素声明为 const。

这个特性可以用来允许 span 在一条语句中修改range的元素。例如，你可以对元素的子集进行排序，如下面的示例所示：

#include <iostream>
#include <string>
#include <vector>
#include <ranges>
#include <algorithm>
#include <span>

void print(std::ranges::input_range auto&& coll)
{
  for (const auto& elem : coll) {
    std::cout << '"' << elem << "\" ";
  }
  std::cout << '\n';
}

int main()
{
  std::vector<std::string> vec{"New York", "Tokyo", "Rio", "Berlin", "Sydney"};
  print(vec);

  // sort the three elements in the middle:
  std::ranges::sort(std::span{vec}.subspan(1, 3));
  print(vec);

  // print last three elements:
  print(std::span{vec}.last(3));
}

在这里，我们创建临时的 spans 来对vector类型 vec 中的元素子集进行排序，并打印向量的最后三个元素。

程序的输出如下：

"New York" "Tokyo" "Rio" "Berlin" "Sydney"

"New York" "Berlin" "Rio" "Tokyo" "Sydney"

"Rio" "Tokyo" "Sydney"

Spans是视图。为了处理range的前n个元素，你还可以使用range工厂std::views::counted()，如果对一个具有连续内存元素的range的迭代器调用它，它会创建一个具有动态长度(extent)的span。

std::vector<int> vec{1, 2, 3, 4, 5, 6, 7, 8, 9};

auto v = std::views::counted(vec.begin()+1, 3); // span with 2nd to 4th elem of vec

9.1.4 使用固定长度(extent)Span的示例

作为一个具有固定长度(extent)的 span 的第一个示例，让我们将前面的示例进行转换，但是声明一个具有固定长度(extent)的 span。

#include <iostream>
#include <string>
#include <vector>
#include <ranges>
#include <algorithm>
#include <span>

template<typename T, std::size_t Sz>
void printSpan(std::span<T, Sz> sp)
{
  for (const auto& elem : sp) {
    std::cout << '"' << elem << "\" ";
  }
  std::cout << '\n';
}

int main()
{
  std::vector<std::string> vec{"New York", "Tokyo", "Rio", "Berlin", "Sydney"};

  // define view to first 3 elements:
  std::span<const std::string, 3> sp3{vec.data(), 3};
  std::cout << "first 3:              ";
  printSpan(sp3);

  // sort referenced elements:
  std::ranges::sort(vec);
  std::cout << "first 3 after sort(): ";
  printSpan(sp3);

  // insert a new element:
  // - must reassign the internal array of the vector if it reallocated new memory
  auto oldCapa = vec.capacity();
  vec.push_back("Cairo");
  if (oldCapa != vec.capacity()) {
    sp3 = std::span<std::string, 3>{vec.data(), 3};
  }
  std::cout << "first 3: ";
  printSpan(sp3);

  // let span refer to the last three elements:
  sp3 = std::span<const std::string, 3>{vec.end()-3, vec.end()};
  std::cout << "last 3:  ";
  printSpan(sp3);

  // let span refer to the last three elements:
  sp3 = std::span{vec}.last<3>();
  std::cout << "last 3:  ";
  printSpan(sp3);
}

程序输出如下：

first 3: "New York" "Tokyo" "Rio"

first 3 after sort(): "Berlin" "New York" "Rio"

first 3: "Berlin" "New York" "Rio"

last 3: "Sydney" "Tokyo" "Cairo"

让我们逐步介绍程序示例中的显著部分。

定义span

这次，我们首先用固定长度(extent)初始化了一个包含三个常量字符串的 span：

std::vector<std::string> vec{"New York", "Rio", "Tokyo", "Berlin", "Sydney"};