What's the difference between span and array_v

Question

In several recent conference presentation I've heard Bjarne Stroustrup and others mention new coding guidelines for C++ and some types supporting them.

Specifically, I remember the example of span<T> instead of (T* p, int n) as a parameter to a function (at time about 32:00 into the talk); but I also remember the suggestion to use array_view<T>. Are they two alternatives but the same concept? Or am I confusing things and they're actually not so related?

I can't seem to find any authoritative definition of what they're both supposed to be about.

Answer 1

The document P0122R (2016-02-12) from the Library Evolution Working Group (LEWG)
officially renames the type array_view to span:

Changelog

Changes from R0

• Changed the name of the type being proposed from array_view to span following feedback from LEWG at the Kona meeting.
• [...]

We can also read:

Impact on the Standard

This proposal is a pure library extension. It does not require any changes to standard classes, functions, or headers. It would be enhanced if could depends on the byte type and changes to type aliasing behavior proposed in P0257.

However – if adopted – it may be useful to overload some standard library functions for this new type (an example would be copy()).

span has been implemented in standard C++ (C++11) and is being successfully used within a commercial static analysis tool for C++ code as well as commercial office productivity software. An open source, reference implementation is available at https://github.com/Microsoft/GSL.

In a next chapter, this documents presents the read-only and read-write (mutable) accesses:

Element types and conversions

span must be configured with its element type via the template parameter ValueType, which is required to be a complete object type that is not an abstract class type. span supports either read-only or mutable access to the sequence it encapsulates. To access read-only data, the user can declare a span<const T>, and access to mutable data would use a span<T>.

[...]

---

See also the Guidelines Support Library Review: span<T> from Marius Bancila (march 2016) defining span as:

The Guidelines Support Library is a Microsoft implementation of some of the types and functions described in the C++ Core Guidelines maintained by the Standard C++ Foundation. Among the types provided by the GSL is span<T> formerly known as array_view<T>.

span<T> is a non-owning range of contiguous memory recommended to be used instead of pointers (and size counter) or standard containers (such as std::vector or std::array).

Answer 2

In the CppCoreGuidlines The original array_view was renamed to span.

See: https://github.com/isocpp/CppCoreGuidelines/pull/377

It is described thus:

span is a bounds-checked, safe alternative to using pointers to access arrays

Answer 3

We talked with people in the library working group in the standards committee. They wanted the array_view they are trying to get into the standard to be read only. For the core guidelines, we needed an abstraction that was read and write. To avoid a clash between the (potential) standards and the guidelines support library (GSL), we renamed our (read and write) array_view to span: https://github.com/microsoft/gsl .