std::span

std::span<T> — невладеющее представление непрерывного диапазона элементов типа T: внутри буквально указатель на первый элемент плюс длина, без владения памятью. Это прямое обобщение идеи std::string_view (см. cpp17/string-view.html) с частного случая "char-массив" на произвольный тип элемента — span<int>, span<Point>, span<std::byte>. span принимает C-массив, std::vector, std::array, любой contiguous-контейнер — без копирования данных.std::span<T> is a non-owning view of a contiguous range of elements of type T: under the hood it's literally a pointer to the first element plus a length, owning none of the memory. It's a direct generalization of the idea behind std::string_view (see cpp17/string-view.html) from the special case of "a char array" to any element type — span<int>, span<Point>, span<std::byte>. span accepts a C array, a std::vector, a std::array, any contiguous container — without copying the data.

// либо шаблон — раздувает код на каждый тип контейнера// either a template — bloats code per container type
template <class Container>
void process(Container& c) { for (auto& x : c) { /*...*//*...*/ } }

// либо указатель+размер раздельными параметрами —// or a pointer+size as two separate parameters —
// легко перепутать порядок или забыть один из них// easy to swap the order or forget one of them
void process(int* data, size_t size);

void process(std::span<int> s) {
    for (int x : s) { /*...*//*...*/ }  // range-for работает// range-for just works
}

int arr[5] = {1,2,3,4,5};
std::vector<int> v = {1,2,3};
std::array<int, 4> a = {1,2,3,4};

process(arr);   // одна сигнатура принимает все три —// one signature accepts all three —
process(v);     // без шаблона, без копирования// no template, no copying
process(a);

Функция, желающая принимать "любой непрерывный массив int-ов", не имела единого удобного способа сделать это до span:A function wanting to accept "any contiguous array of ints" had no single convenient way to do it before span:

Как и string_view, span внутри — пара "указатель + размер", ничего не аллоцирующая и не освобождающая. Отличие — необязательный второй шаблонный параметр Extent: std::span<int> (динамический размер, по умолчанию std::dynamic_extent) хранит размер в рантайме как поле, а std::span<int, 10> (статический размер) знает размер на этапе компиляции — само число становится частью типа, и объект span в этом случае может обойтись без поля размера вовсе.Like string_view, span is internally a "pointer + size" pair, allocating and freeing nothing. The difference is an optional second template parameter, Extent: std::span<int> (dynamic extent, defaulting to std::dynamic_extent) stores the size at runtime as a field, while std::span<int, 10> (static extent) knows the size at compile time — the number itself becomes part of the type, and in that case the span object can skip the size field entirely.

#include <span>

void sum_all(std::span<const int> s) {   // динамический размер — обычный выбор// dynamic extent — the usual choice
    int total = 0;
    for (int x : s) total += x;
}

int arr[10];
std::span<int, 10> fixed = arr;     // статический размер — известен как часть типа// static extent — known as part of the type
std::span<int> dyn = fixed;          // static -> dynamic: implicit, разрешено// static -> dynamic: implicit, allowed
// std::span<int, 10> back = dyn;  // dynamic -> static: НЕ implicit// std::span<int, 10> back = dyn;  // dynamic -> static: NOT implicit

std::vector<int> v = {1,2,3,4,5};
std::span<int> view(v);
auto firstTwo = view.first(2);       // {1, 2}, без копирования// {1, 2}, no copying
auto middle = view.subspan(1, 3);  // {2, 3, 4}, без копирования// {2, 3, 4}, no copying

Три метода — .first(n), .last(n), .subspan(offset, count) — возвращают новый span, указывающий внутрь того же буфера с другими границами, без единой аллокации или копии элемента. Это ровно то же отношение к данным, что у string_view::substr, только для произвольного типа элемента, а не только char:Three methods — .first(n), .last(n), .subspan(offset, count) — return a new span pointing into the same buffer with different bounds, with no allocation or element copy whatsoever. This is exactly the same relationship to the data as string_view::substr, just for any element type, not only char:

std::vector<int> data = {10,20,30,40,50,60};
std::span<int> s(data);

auto head = s.first(2);              // {10, 20} — первые 2 элемента// {10, 20} — the first 2 elements
auto tail = s.last(2);               // {50, 60} — последние 2 элемента// {50, 60} — the last 2 elements
auto middlePart = s.subspan(2, 3);   // {30, 40, 50} — 3 элемента, начиная с индекса 2// {30, 40, 50} — 3 elements starting at index 2
auto fromMiddle = s.subspan(3);      // {40, 50, 60} — count опущен: "до конца"// {40, 50, 60} — count omitted: "to the end"
// все четыре — span, смотрящие в тот же буфер data, ни одной копии// all four are spans pointing into the same data buffer, zero copies

• cppreference — std::span
• WG21 P0122 — std::span