What's the difference between span and array_view in the gsl library?
C++Cpp Core-GuidelinesGuideline Support-LibraryArray ViewC++ Problem Overview
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.
C++ Solutions
Solution 1 - C++
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 .
Solution 2 - C++
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
Solution 3 - C++
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](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0257r0.html "Neil MacIntosh, “A byte type for increased type safety”, P0257, 2016").
>
> 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
).