class Span

Implicit conversion constructors

Explicit reference constructor for a mutable `Span

<T

>` type. Can be

replaced with MakeSpan() to infer the type parameter.

Implicit reference constructor for a read-only `Span

<const

T>` type

Overloads of the above two functions that are only enabled for view types.

This is so we can drop the ABSL_ATTRIBUTE_LIFETIME_BOUND annotation. These

overloads must be made unique by using a different template parameter list

(hence the = 0 for the IsView enabler).

Implicit constructor from an initializer list, making it possible to pass a

brace-enclosed initializer list to a function expecting a `Span`. Such

spans constructed from an initializer list must be of type `Span

<const

T>`.

void Process(absl::Span

<const

int> x);

Process({1, 2, 3});

Note that as always the array referenced by the span must outlive the span.

Since an initializer list constructor acts as if it is fed a temporary

array (cf. C++ standard [dcl.init.list]/5), it's safe to use this

constructor only when the `std::initializer_list` itself outlives the span.

In order to meet this requirement it's sufficient to ensure that neither

the span nor a copy of it is used outside of the expression in which it's

created:

// Assume that this function uses the array directly, not retaining any

// copy of the span or pointer to any of its elements.

void Process(absl::Span

<const

int> ints);

// Okay: the std::initializer_list

<int

> will reference a temporary array

// that isn't destroyed until after the call to Process returns.

Process({ 17, 19 });

// Not okay: the storage used by the std::initializer_list

<int

> is not

// allowed to be referenced after the first line.

absl::Span

<const

int> ints = { 17, 19 };

Process(ints);

// Not okay for the same reason as above: even when the elements of the

// initializer list expression are not temporaries the underlying array

// is, so the initializer list must still outlive the span.

const int foo = 17;

absl::Span

<const

int> ints = { foo };

Process(ints);

Span::data()

Returns a pointer to the span's underlying array of data (which is held

outside the span).

Span::size()

Returns the size of this span.

Span::length()

Returns the length (size) of this span.

Span::empty()

Returns a boolean indicating whether or not this span is considered empty.

Span::operator[]

Returns a reference to the i'th element of this span.

Span::at()

Returns a reference to the i'th element of this span.

Span::front()

Returns a reference to the first element of this span. The span must not

be empty.

Span::back()

Returns a reference to the last element of this span. The span must not

be empty.

Span::begin()

Returns an iterator pointing to the first element of this span, or `end()`

if the span is empty.

Span::cbegin()

Returns a const iterator pointing to the first element of this span, or

`end()` if the span is empty.

Span::end()

Returns an iterator pointing just beyond the last element at the

end of this span. This iterator acts as a placeholder; attempting to

access it results in undefined behavior.

Span::cend()

Returns a const iterator pointing just beyond the last element at the

end of this span. This iterator acts as a placeholder; attempting to

access it results in undefined behavior.

Span::rbegin()

Returns a reverse iterator pointing to the last element at the end of this

span, or `rend()` if the span is empty.

Span::crbegin()

Returns a const reverse iterator pointing to the last element at the end of

this span, or `crend()` if the span is empty.

Span::rend()

Returns a reverse iterator pointing just before the first element

at the beginning of this span. This pointer acts as a placeholder;

attempting to access its element results in undefined behavior.

Span::crend()

Returns a reverse const iterator pointing just before the first element

at the beginning of this span. This pointer acts as a placeholder;

attempting to access its element results in undefined behavior.

Span::remove_prefix()

Removes the first `n` elements from the span.

Span::remove_suffix()

Removes the last `n` elements from the span.

Span::subspan()

Returns a `Span` starting at element `pos` and of length `len`. Both `pos`

and `len` are of type `size_type` and thus non-negative. Parameter `pos`

must be

<

= size(). Any `len` value that points past the end of the span

will be trimmed to at most size() - `pos`. A default `len` value of `npos`

ensures the returned subspan continues until the end of the span.

Examples:

std::vector

<int

> vec = {10, 11, 12, 13};

absl::MakeSpan(vec).subspan(1, 2); // {11, 12}

absl::MakeSpan(vec).subspan(2, 8); // {12, 13}

absl::MakeSpan(vec).subspan(1); // {11, 12, 13}

absl::MakeSpan(vec).subspan(4); // {}

absl::MakeSpan(vec).subspan(5); // throws std::out_of_range

Span::first()

Returns a `Span` containing first `len` elements. Parameter `len` is of

type `size_type` and thus non-negative. `len` value must be

<

= size().

Examples:

std::vector

<int

> vec = {10, 11, 12, 13};

absl::MakeSpan(vec).first(1); // {10}

absl::MakeSpan(vec).first(3); // {10, 11, 12}

absl::MakeSpan(vec).first(5); // throws std::out_of_range

Span::last()

Returns a `Span` containing last `len` elements. Parameter `len` is of

type `size_type` and thus non-negative. `len` value must be

<

= size().

Examples:

std::vector

<int

> vec = {10, 11, 12, 13};

absl::MakeSpan(vec).last(1); // {13}

absl::MakeSpan(vec).last(3); // {11, 12, 13}

absl::MakeSpan(vec).last(5); // throws std::out_of_range