8.4.5 String View

The class template std::basic_string_view<> and its specializations std::string_view, std::u16string_view, std::u32string_view, and std::wstring_view are the only view types that were already available in the C++17 standard library. However, C++20 adds the specialization for UTF-8 characters: std::u8string_view.

String views do not follow a couple of conventions that views usually have:

•The view is defined in the namespace std (instead of std::ranges).

•The view has its own header file <string_view>.

•The view has no range adaptor/factory to create view objects.

•The view provides only read access to the elements/characters.

•The view provides cbegin() and cend() member functions.

•The view supports no conversion to bool.

For example:

for (char c : std::string_view{"hello"}) { std::cout << c << ' ';

}

std::cout << '\n';

This loop has the following output: h e l l o

Special Characteristics of String Views

Iterators do not refer to this view. Instead, they refer to the underlying character sequence. Therefore, a string view is a borrowed range. However, note that iterators can still dangle when the underlying character sequence is no longer there.

View-Specific Interface of String Views

Table View operations of the class std::basic_string_view<> lists the view-relevant parts of the API of a string view.

Table 8.12. View operations of the class std::ranges::basic_string_view<>

In addition to the usual interface of views, the type also provides the full API of all read-only operations of strings.

For more details, take a look at my book C++17 - The Complete Guide (see http://www.cppstd17. com).

8.4.6 Span

The class template std::span<> is a view to a sequence of elements that are stored in contiguous memory. It is described in its own chapter in detail. Here, we present only the properties of spans as a view.

The major benefit of spans is that they support referring to a subrange of n elements in the middle or at the end of the referred range. For example:

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

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

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

This example is discussed later in a section of the chapter about spans.

Note that spans do not follow a couple of conventions that views usually have:

•The view is defined in the namespace std instead of std::ranges.

•The view has its own header file <span>.

•The view supports no conversion to bool.

Range Factories for Spans

There is no range factory for initializing a span from a begin (iterator) and an end (sentinel). However, there is a range factory that might create a span from begin and a count:

std::views::counted(beg, sz)

std::views::counted() creates a span of dynamic size initialized with the first sz elements of the contiguous range, starting with the iterator beg (for a non-contiguous range, counted() creates a subrange).

For example:

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

When std::views::counted() creates a span, the span has dynamic extent (its size can vary).

Special Characteristics of Spans

Iterators do not refer to a span. Instead, they refer to the underlying elements. Therefore, a span is a borrowed range. However, note that iterators can still dangle when the underlying character sequence is no longer there.

View-Specific Interface of Spans

Table View operations of the class std::span<> lists the view-relevant parts of the API of a span.

For more details, see the section about span operations.