span lite - A C++20-like span for C++98, C++11 and later in a single-file header-only library

span lite: A single-file header-only version of a C++20-like span for C++98, C++11 and later

Language License Build Status Build status Version download Conan Try it on wandbox Try it on godbolt online

Contents

Example usage

#include "nonstd/span.hpp"
#include <array>
#include <vector>
#include <iostream>

std::ptrdiff_t size( nonstd::span<const int> spn )
{
    return spn.size();
}

int main()
{
    int arr[] = { 1, };

    std::cout << 
        "C-array:" << size( arr ) <<
        " array:"  << size( std::array <int, 2>{ 1, 2, } ) <<
        " vector:" << size( std::vector<int   >{ 1, 2, 3, } );
}

Compile and run

prompt> g++ -std=c++11 -Wall -I../include -o 01-basic.exe 01-basic.cpp && 01-basic.exe
C-array:1 array:2 vector:3

In a nutshell

span lite is a single-file header-only library to provide a bounds-safe view for sequences of objects. The library provides a C++20-like span for use with C++98 and later. If available, std::span is used, unless configured otherwise. span-lite can detect the presence of byte-lite and if present, it provides as_bytes() and as_writable_bytes() also for C++14 and earlier.

Features and properties of span lite are ease of installation (single header), freedom of dependencies other than the standard library. To compensate for the class template argument deduction that is missing from pre-C++17 compilers, nonstd::span can provide make_span functions. See configuration.

License

span lite is distributed under the Boost Software License.

Dependencies

span lite has no other dependencies than the C++ standard library.

Installation and use

span lite is a single-file header-only library. Put span.hpp in the include folder directly into the project source tree or somewhere reachable from your project.

Synopsis

Contents
Documentation of std::span
Later additions
Non-standard extensions
Configuration

Documentation of std::span

Depending on the compiler and C++-standard used, nonstd::span behaves less or more like std::span. To get an idea of the capabilities of nonstd::span with your configuration, look at the output of the tests, issuing span-main.t --pass @. For std::span, see its documentation at cppreference.

Later additions

back() and front()

span lite can provide back() and front() member functions for element access. See the table below and section configuration.

Non-standard extensions

Construct from container

To construct a span from a container with compilers that cannot constrain such a single-parameter constructor to containers, span lite provides a constructor that takes an additional parameter of type with_container_t. Use with_container as value for this parameter. See the table below and section configuration.

Construct from std::array with const data

span lite can provide construction of a span from a std::array with const data. See the table below and section configuration.

operator()

span lite can provide member function call operator() for element access. It is equivalent to operator[] and has been marked [[deprecated]]. Its main purpose is to provide a migration path.

at()

span lite can provide member function at() for element access. Unless exceptions have been disabled, at() throws std::out_of_range if the index falls outside the span. With exceptions disabled, at(index_t) delegates bounds checking to operator[](index_t). See the table below and sections configuration and disable exceptions.

swap()

span lite can provide a swap()member function. See the table below and section configuration.

operator==() and other comparison functions

span lite can provide functions to compare the content of two spans. However, C++20's span will not provide comparison and span lite will omit comparison at default in the near future. See the table below and section configuration. See also Revisiting Regular Types.

same()

span lite can provide function same() to determine if two spans refer as identical spans to the same data via the same type. If same() is enabled, operator==() incorporates it in its comparison. See the table below and section configuration.

first(), last() and subspan()

span lite can provide functions first(), last() and subspan() to avoid having to use the dot template syntax when the span is a dependent type. See the table below and section configuration.

make_span()

span lite can provide make_span() creator functions to compensate for the class template argument deduction that is missing from pre-C++17 compilers. See the table below and section configuration.

byte_span()

span lite can provide byte_span() creator functions to represent an object as a span of bytes. This requires the C++17 type std::byte to be available. See the table below and section configuration.

Kind std Function or method
Macro   macro span_FEATURE_WITH_CONTAINER
macro span_FEATURE_WITH_CONTAINER_TO_STD
Types   with_container_t type to disambiguate below constructors
Objects   with_container value to disambiguate below constructors
Constructors   macro span_FEATURE_CONSTRUCTION_FROM_STDARRAY_ELEMENT_TYPE
    template<class Container>
constexpr span(with_container_t, Container & cont)
    template<class Container>
constexpr span(with_container_t, Container const & cont)
     
Methods   macro span_FEATURE_MEMBER_CALL_OPERATOR
    constexpr reference operator()(index_t idx) const
Equivalent to operator[](), marked [[deprecated]]
     
Methods   macro span_FEATURE_MEMBER_AT
    constexpr reference at(index_t idx) const
May throw std::out_of_range exception
     
Methods   macro span_FEATURE_MEMBER_BACK_FRONT (on since v0.5.0)
    constexpr reference back() const noexcept
    constexpr reference front() const noexcept
     
Method   macro span_FEATURE_MEMBER_SWAP
    constexpr void swap(span & other) noexcept
     
Free functions   macro span_FEATURE_COMPARISON


== != < > <= >=
  template<class T1, index_t E1, class T2, index_t E2>
constexpr bool
operator==( span<T1,E1> const & l, span<T2,E2> const & r) noexcept
     
Free function   macro span_FEATURE_SAME
    template<class T1, index_t E1, class T2, index_t E2>
constexpr bool
same( span<T1,E1> const & l, span<T2,E2> const & r) noexcept
     
Free functions
 
 
  macros span_FEATURE_NON_MEMBER_FIRST_LAST_SUB,
span_FEATURE_NON_MEMBER_FIRST_LAST_SUB_SPAN,
span_FEATURE_NON_MEMBER_FIRST_LAST_SUB_CONTAINER
     
Free functions   macro span_FEATURE_NON_MEMBER_FIRST_LAST_SUB_SPAN
    template<extent_t Count, class T, extent_t Extent>
constexpr span<T,Count>
first(span<T,Extent> spn)
    template<class T, extent_t Extent >
constexpr span<T>
first(span<T,Extent> spn, size_t count)
    template<extent_t Count, class T, extent_t Extent>
constexpr span<T,Count>
last(span<T,Extent> spn)
    template<class T, extent_t Extent >
constexpr span<T>
last(span<T,Extent> spn, size_t count)
    template<size_t Offset, extent_t Count, class T, extent_t Extent>
constexpr span<T, Count>
subspan(span<T, Extent> spn)
    template<class T, extent_t Extent>
constexpr span<T>
subspan( span<T, Extent> spn, size_t offset, extent_t count = dynamic_extent)
     
Free functions   macro span_FEATURE_NON_MEMBER_FIRST_LAST_SUB_CONTAINER
  >= C++11 template<extent_t Count, class T>
constexpr auto
first(T & t) ->...
  >= C++11 template<class T>
constexpr auto
first(T & t, index_t count) ->...
  >= C++11 template<extent_t Count, class T>
constexpr auto
last(T & t) ->...
  >= C++11 template<class T>
constexpr auto
last(T & t, extent_t count) ->...
  >= C++11 template<index_t Offset, extent_t Count = dynamic_extent, class T>
constexpr auto
subspan(T & t) ->...
  >= C++11 template<class T>
constexpr auto
subspan(T & t, index_t offset, extent_t count = dynamic_extent) ->...
     
Free functions   macro span_FEATURE_MAKE_SPAN
macro span_FEATURE_MAKE_SPAN_TO_STD
    template<class T>
constexpr span<T>
make_span(T * first, T * last) noexcept
    template<class T>
constexpr span<T>
make_span(T * ptr, index_t count) noexcept
    template<class T, size_t N>
constexpr span<T,N>
make_span(T (&arr)[N]) noexcept
  >= C++11 template<class T, size_t N>
constexpr span<T,N>
make_span(std::array<T,N> & arr) noexcept
  >= C++11 template<class T, size_t N>
constexpr span<const T,N>
make_span(std::array<T,N > const & arr) noexcept
  >= C++11 template<class Container>
constexpr auto
make_span(Container & cont) ->
 span<typename Container::value_type> noexcept
  >= C++11 template<class Container>
constexpr auto
make_span(Container const & cont) ->
 span<const typename Container::value_type> noexcept
    template<class Container>
span<typename Container::value_type>
make_span( with_container_t, Container & cont )
    template<class Container>
span<const typename Container::value_type>
make_span( with_container_t, Container const & cont )
  < C++11 template<class T, Allocator>
span<T>
make_span(std::vector<T, Allocator> & cont)
  < C++11 template<class T, Allocator>
span<const T>
make_span(std::vector<T, Allocator> const & cont)
     
Free functions   macro span_FEATURE_BYTE_SPAN
  >= C++11 template<class T>
span<T, sizeof(T)>
byte_span(T & t)
  >= C++11 template<class T>
span<const T, sizeof(T)>
byte_span(T const & t)

Configuration

Tweak header

If the compiler supports __has_include(), span lite supports the tweak header mechanism. Provide your tweak header as nonstd/span.tweak.hpp in a folder in the include-search-path. In the tweak header, provide definitions as documented below, like #define span_CONFIG_NO_EXCEPTIONS 1.

Standard selection macro

-Dspan_CPLUSPLUS=199711L
Define this macro to override the auto-detection of the supported C++ standard, if your compiler does not set the __cplusplus macro correctly.

Select std::span or nonstd::span

At default, span lite uses std::span if it is available and lets you use it via namespace nonstd. You can however override this default and explicitly request to use std::span or span lite's nonstd::span as nonstd::span via the following macros.

-Dspan_CONFIG_SELECT_SPAN=span_SPAN_DEFAULT
Define this to span_SPAN_STD to select std::span as nonstd::span. Define this to span_SPAN_NONSTD to select nonstd::span as nonstd::span. Default is undefined, which has the same effect as defining to span_SPAN_DEFAULT.

Select extent type

-Dspan_CONFIG_EXTENT_TYPE=std::size_t
Define this to std::ptrdiff_t to use the signed type. The default is std::size_t, as in C++20 (since v0.7.0).

Select size type

-Dspan_CONFIG_SIZE_TYPE=std::size_t
Define this to std::ptrdiff_t to use the signed type. The default is std::size_t, as in C++20 (since v0.7.0). Note span_CONFIG_SIZE_TYPE replaces span_CONFIG_INDEX_TYPE which is deprecated.

Disable exceptions

-Dspan_CONFIG_NO_EXCEPTIONS=0
Define this to 1 if you want to compile without exceptions. If not defined, the header tries and detect if exceptions have been disabled (e.g. via -fno-exceptions). Disabling exceptions will force contract violation to use termination, see contract violation macros. Default is undefined.

Provide construction using with_container_t

-Dspan_FEATURE_WITH_CONTAINER=0
Define this to 1 to enable constructing a span using with_container_t. Note that span_FEATURE_WITH_CONTAINER takes precedence over span_FEATURE_WITH_CONTAINER_TO_STD. Default is undefined.

-Dspan_FEATURE_WITH_CONTAINER_TO_STD=n
Define this to the highest C++ language version for which to enable constructing a span using with_container_t, like 98, 03, 11, 14, 17, 20. You can use 99 for inclusion with any standard, but prefer to use span_FEATURE_WITH_CONTAINER for this. Note that span_FEATURE_WITH_CONTAINER takes precedence over span_FEATURE_WITH_CONTAINER_TO_STD. Default is undefined.

Provide construction from std::array with const data

-Dspan_FEATURE_CONSTRUCTION_FROM_STDARRAY_ELEMENT_TYPE=0
Define this to 1 to enable constructing a span from a std::array with const data. Default is undefined.

Provide operator() member function

-Dspan_FEATURE_MEMBER_CALL_OPERATOR=0
Define this to 1 to provide member function operator()for element access. It is equivalent to operator[] and has been marked [[deprecated]]. Its main purpose is to provide a migration path. Default is undefined.

Provide at() member function

-Dspan_FEATURE_MEMBER_AT=0
Define this to 1 to provide member function at(). Define this to 2 to include index and size in message of std::out_of_range exception. Default is undefined.

Provide back() and front() member functions

-Dspan_FEATURE_MEMBER_BACK_FRONT=1 (on since v0.5.0)
Define this to 0 to omit member functions back() and front(). Default is undefined.

Provide swap() member function

-Dspan_FEATURE_MEMBER_SWAP=0
Define this to 1 to provide member function swap(). Default is undefined.

Provide operator==() and other comparison functions

-Dspan_FEATURE_COMPARISON=0
Define this to 1 to include the comparison functions to compare the content of two spans. C++20's span does not provide comparison and span lite omits comparison from v0.7.0. Default is undefined.

Provide same() function

-Dspan_FEATURE_SAME=0
Define this to 1 to provide function same() to test if two spans refer as identical spans to the same data via the same type. If same() is enabled, operator==() incorporates it in its comparison. Default is undefined.

Provide first(), last() and subspan() functions

-Dspan_FEATURE_NON_MEMBER_FIRST_LAST_SUB=0
Define this to 1 to enable both span_FEATURE_NON_MEMBER_FIRST_LAST_SUB_SPAN and span_FEATURE_NON_MEMBER_FIRST_LAST_SUB_CONTAINER. Default is undefined.

-Dspan_FEATURE_NON_MEMBER_FIRST_LAST_SUB_SPAN=0
Define this to 1 to provide functions first(), last() and subspan() that take a span<> (work with C++98). This implies span_FEATURE_MAKE_SPAN to provide functions make_span() that are required for this feature. Default is undefined.

-Dspan_FEATURE_NON_MEMBER_FIRST_LAST_SUB_CONTAINER=0
Define this to 1 to provide functions first(), last() and subspan() that take a compatible container (requires C++11). This implies span_FEATURE_MAKE_SPAN to provide functions make_span() that are required for this feature. Default is undefined.

Provide make_span() functions

-Dspan_FEATURE_MAKE_SPAN=0
Define this to 1 to provide creator functions nonstd::make_span(). This feature is implied by using span_FEATURE_NON_MEMBER_FIRST_LAST_SUB=1. Note that span_FEATURE_MAKE_SPAN takes precedence over span_FEATURE_MAKE_SPAN_TO_STD. Default is undefined.

-Dspan_FEATURE_MAKE_SPAN_TO_STD=n
Define this to the highest C++ language version for which to provide creator functions nonstd::make_span(), like 98, 03, 11, 14, 17, 20. You can use 99 for inclusion with any standard, but prefer to use span_FEATURE_MAKE_SPAN for this. Note that span_FEATURE_MAKE_SPAN takes precedence over span_FEATURE_MAKE_SPAN_TO_STD. Default is undefined.

Provide byte_span() functions

-Dspan_FEATURE_BYTE_SPAN=0
Define this to 1 to provide creator functions nonstd::byte_span(). Default is undefined.

Contract violation response macros

span-lite provides contract violation response control as suggested in proposal N4415.

-Dspan_CONFIG_CONTRACT_LEVEL_ON (default)
Define this macro to include both span_EXPECTS and span_ENSURES in the code. This is the default case.

-Dspan_CONFIG_CONTRACT_LEVEL_OFF
Define this macro to exclude both span_EXPECTS and span_ENSURES from the code.

-Dspan_CONFIG_CONTRACT_LEVEL_EXPECTS_ONLY
Define this macro to include span_EXPECTS in the code and exclude span_ENSURES from the code.

-Dspan_CONFIG_CONTRACT_LEVEL_ENSURES_ONLY
Define this macro to exclude span_EXPECTS from the code and include span_ENSURES in the code.

-Dspan_CONFIG_CONTRACT_VIOLATION_TERMINATES (default)
Define this macro to call std::terminate() on a contract violation in span_EXPECTS, span_ENSURES. This is the default case.

-Dspan_CONFIG_CONTRACT_VIOLATION_THROWS
Define this macro to throw an exception of implementation-defined type that is derived from std::runtime_exception instead of calling std::terminate() on a contract violation in span_EXPECTS and span_ENSURES. See also disable exceptions.

Reported to work with

The table below mentions the compiler versions span lite is reported to work with.

OS Compiler Where Versions
GNU/Linux Clang/LLVM Travis 3.5.0, 3.6.2, 3.7.1, 3.8.0, 3.9.1, 4.0.1
  GCC Travis 5.5.0, 6.4.0, 7.3.0
OS X ? Local ?
Windows Clang/LLVM Local 6.0.0
  GCC Local 7.2.0
  Visual C++
(Visual Studio)
Local 8 (2005), 10 (2010), 11 (2012),
12 (2013), 14 (2015), 15 (2017)
  Visual C++
(Visual Studio)
AppVeyor 10 (2010), 11 (2012),
12 (2013), 14 (2015), 15 (2017)

Building the tests

To build the tests you need:

The lest test framework is included in the test folder.

The following steps assume that the span lite source code has been cloned into a directory named ./span-lite.

  1. Create a directory for the build outputs.

     cd ./span-lite
     md build && cd build
    
  2. Configure CMake to use the compiler of your choice (run cmake --help for a list).

     cmake -G "Unix Makefiles" -DSPAN_LITE_OPT_BUILD_TESTS=ON ..
    
  3. Optional. You can control above configuration through the following options:

    -DSPAN_LITE_OPT_BUILD_TESTS=ON: build the tests for span, default off
    -DSPAN_LITE_OPT_BUILD_EXAMPLES=OFF: build the examples, default off

  4. Build the test suite.

     cmake --build .
    
  5. Run the test suite.

     ctest -V
    

All tests should pass, indicating your platform is supported and you are ready to use span lite.

Other implementations of span

Notes and references

Interface and specification

Presentations

  • TBD

Proposals

Appendix

A.1 Compile-time information

The version of span lite is available via tag [.version]. The following tags are available for information on the compiler and on the C++ standard library used: [.compiler], [.stdc++], [.stdlanguage] and [.stdlibrary].

A.2 Span lite test specification

click to expand

span<>: Terminates construction from a nullptr and a non-zero size (C++11)
span<>: Terminates construction from two pointers in the wrong order
span<>: Terminates construction from a null pointer and a non-zero size
span<>: Terminates creation of a sub span of the first n elements for n exceeding the span
span<>: Terminates creation of a sub span of the last n elements for n exceeding the span
span<>: Terminates creation of a sub span outside the span
span<>: Terminates access outside the span
span<>: Throws  on access outside the span via at(): std::out_of_range [span_FEATURE_MEMBER_AT>0][span_CONFIG_NO_EXCEPTIONS=0]
span<>: Termination throws std::logic_error-derived exception [span_CONFIG_CONTRACT_VIOLATION_THROWS=1]
span<>: Allows to default-construct
span<>: Allows to construct from a nullptr and a zero size (C++11)
span<>: Allows to construct from two pointers
span<>: Allows to construct from two iterators
span<>: Allows to construct from two iterators - empty range
span<>: Allows to construct from two iterators - move-only element
span<>: Allows to construct from an iterator and a size
span<>: Allows to construct from an iterator and a size - empty range
span<>: Allows to construct from an iterator and a size - move-only element
span<>: Allows to construct from two pointers to const
span<>: Allows to construct from a non-null pointer and a size
span<>: Allows to construct from a non-null pointer to const and a size
span<>: Allows to construct from a temporary pointer and a size
span<>: Allows to construct from a temporary pointer to const and a size
span<>: Allows to construct from any pointer and a zero size (C++98)
span<>: Allows to construct from a pointer and a size via a deduction guide (C++17)
span<>: Allows to construct from an iterator and a size via a deduction guide (C++17)
span<>: Allows to construct from two iterators via a deduction guide (C++17)
span<>: Allows to construct from a C-array
span<>: Allows to construct from a C-array via a deduction guide (C++17)
span<>: Allows to construct from a const C-array
span<>: Allows to construct from a C-array with size via decay to pointer (potentially dangerous)
span<>: Allows to construct from a const C-array with size via decay to pointer (potentially dangerous)
span<>: Allows to construct from a std::initializer_list<> (C++11)
span<>: Allows to construct from a std::array<> (C++11)
span<>: Allows to construct from a std::array via a deduction guide (C++17)
span<>: Allows to construct from a std::array<> with const data (C++11, span_FEATURE_CONSTR..._ELEMENT_TYPE=1)
span<>: Allows to construct from an empty std::array<> (C++11)
span<>: Allows to construct from a container (std::vector<>)
span<>: Allows to construct from a container via a deduction guide (std::vector<>, C++17)
span<>: Allows to tag-construct from a container (std::vector<>)
span<>: Allows to tag-construct from a const container (std::vector<>)
span<>: Allows to copy-construct from another span of the same type
span<>: Allows to copy-construct from another span of a compatible type
span<>: Allows to copy-construct from a temporary span of the same type (C++11)
span<>: Allows to copy-assign from another span of the same type
span<>: Allows to copy-assign from a temporary span of the same type (C++11)
span<>: Allows to create a sub span of the first n elements
span<>: Allows to create a sub span of the last n elements
span<>: Allows to create a sub span starting at a given offset
span<>: Allows to create a sub span starting at a given offset with a given length
span<>: Allows to observe an element via array indexing
span<>: Allows to observe an element via call indexing
span<>: Allows to observe an element via at() [span_FEATURE_MEMBER_AT>0]
span<>: Allows to observe an element via data()
span<>: Allows to observe the first element via front() [span_FEATURE_MEMBER_BACK_FRONT=1]
span<>: Allows to observe the last element via back() [span_FEATURE_MEMBER_BACK_FRONT=1]
span<>: Allows to change an element via array indexing
span<>: Allows to change an element via call indexing
span<>: Allows to change an element via at() [span_FEATURE_MEMBER_AT>0]
span<>: Allows to change an element via data()
span<>: Allows to change the first element via front() [span_FEATURE_MEMBER_BACK_FRONT=1]
span<>: Allows to change the last element via back() [span_FEATURE_MEMBER_BACK_FRONT=1]
span<>: Allows to swap with another span [span_FEATURE_MEMBER_SWAP=1]
span<>: Allows forward iteration
span<>: Allows const forward iteration
span<>: Allows reverse iteration
span<>: Allows const reverse iteration
span<>: Allows to identify if a span is the same as another span [span_FEATURE_SAME=1]
span<>: Allows to compare equal to another span of the same type [span_FEATURE_COMPARISON=1]
span<>: Allows to compare unequal to another span of the same type [span_FEATURE_COMPARISON=1]
span<>: Allows to compare less than another span of the same type [span_FEATURE_COMPARISON=1]
span<>: Allows to compare less than or equal to another span of the same type [span_FEATURE_COMPARISON=1]
span<>: Allows to compare greater than another span of the same type [span_FEATURE_COMPARISON=1]
span<>: Allows to compare greater than or equal to another span of the same type [span_FEATURE_COMPARISON=1]
span<>: Allows to compare to another span of the same type and different cv-ness [span_FEATURE_SAME=0]
span<>: Allows to compare empty spans as equal [span_FEATURE_COMPARISON=1]
span<>: Allows to test for empty span via empty(), empty case
span<>: Allows to test for empty span via empty(), non-empty case
span<>: Allows to obtain the number of elements via size()
span<>: Allows to obtain the number of elements via ssize()
span<>: Allows to obtain the number of bytes via size_bytes()
span<>: Allows to view the elements as read-only bytes
span<>: Allows to view and change the elements as writable bytes
make_span() [span_FEATURE_MAKE_SPAN_TO_STD=99]
make_span(): Allows building from two pointers
make_span(): Allows building from two const pointers
make_span(): Allows building from a non-null pointer and a size
make_span(): Allows building from a non-null const pointer and a size
make_span(): Allows building from a C-array
make_span(): Allows building from a const C-array
make_span(): Allows building from a std::initializer_list<> (C++11)
make_span(): Allows building from a std::array<> (C++11)
make_span(): Allows building from a const std::array<> (C++11)
make_span(): Allows building from a container (std::vector<>)
make_span(): Allows building from a const container (std::vector<>)
make_span(): Allows building from a container (with_container_t, std::vector<>)
make_span(): Allows building from a const container (with_container_t, std::vector<>)
byte_span() [span_FEATURE_BYTE_SPAN=1]
byte_span(): Allows building a span of std::byte from a single object (C++17, byte-lite)
byte_span(): Allows building a span of const std::byte from a single const object (C++17, byte-lite)
first(), last(), subspan() [span_FEATURE_NON_MEMBER_FIRST_LAST_SUB=1]
first(): Allows to create a sub span of the first n elements (span, template parameter)
first(): Allows to create a sub span of the first n elements (span, function parameter)
first(): Allows to create a sub span of the first n elements (compatible container, template parameter)
first(): Allows to create a sub span of the first n elements (compatible container, function parameter)
last(): Allows to create a sub span of the last n elements (span, template parameter)
last(): Allows to create a sub span of the last n elements (span, function parameter)
last(): Allows to create a sub span of the last n elements (compatible container, template parameter)
last(): Allows to create a sub span of the last n elements (compatible container, function parameter)
subspan(): Allows to create a sub span starting at a given offset (span, template parameter)
subspan(): Allows to create a sub span starting at a given offset (span, function parameter)
subspan(): Allows to create a sub span starting at a given offset (compatible container, template parameter)
subspan(): Allows to create a sub span starting at a given offset (compatible container, function parameter)
size(): Allows to obtain the number of elements via size()
ssize(): Allows to obtain the number of elements via ssize()
tuple_size<>: Allows to obtain the number of elements via std::tuple_size<> (C++11)
tuple_element<>: Allows to obtain an element via std::tuple_element<> (C++11)
tuple_element<>: Allows to obtain an element via std::tuple_element_t<> (C++11)
get<I>(spn): Allows to access an element via std::get<>()
tweak header: reads tweak header if supported [tweak]

Owner
Martin Moene
C++ programmer at Universiteit Leiden, member and former webeditor of @accu-org.
Martin Moene
Comments
  • Consider implementing P2447

    Consider implementing P2447

    Please consider implementing P2447 (std::span and the missing constructor), possibly as an opt-in optional feature since it hasn't been accepted into the C++ standard yet. Thanks!

  • A few small suggestions

    A few small suggestions

    Great job. Thanks for creating & releasing this. Have you considered offering it for use in libc++/clang? It would be good if you could add the static size optimisation (at some point).

    I have been experimenting with it & testing it with Clang 6.0 & C++17.

    Here’s my feedback & suggestions:

    • Add #include <algorithm> (for lexicographical_compare).
    • The with_container_t stuff appears redundant (with Clang 6.0 & C++17).
    • In namespace nonstd add using span_lite::as_bytes; and using span_lite::as_writeable_bytes; (after line 932).
    • The operator== fails to compile with:
        static const uint8_t data[] = { 0,1,2,3,4,5,6,7,8,9,10 };
        span<uint8_t const> span_data(data);
        assert(make_span(data) == span_data);	// Compile error
    

    I fixed it by adding template<class T> struct is_span_oracle<span<T>> : std::true_type {}; (by the current is_span_oracle) and changed operator==, != etc. to something like:

    template<class T1, index_t L1, class T2, index_t L2> inline constexpr bool
    operator==(span<T1, L1> l, span<T2, L2> r)
        { return (l.cbegin() == r.cbegin() && l.size() == r.size()) ||
                 equal(l.cbegin(), l.cend(), r.cbegin(), r.cend()); }
    
    template<class T1, index_t L1, class T2, index_t L2> inline constexpr bool
    operator<(span<T1, L1> l, span<T2, L2> r)
        { return lexicographical_compare(l.cbegin(), l.cend(), r.cbegin(), r.cend()); }
    
    template<class T1, index_t L1, class T2, index_t L2> inline constexpr bool
    operator!=(span<T1, L1> l, span<T2, L2> r)	{ return !(l == r); }
    
    template<class T1, index_t L1, class T2, index_t L2> inline constexpr bool
    operator<=(span<T1, L1> l, span<T2, L2> r)	{ return !(r < l); }
    
    template<class T1, index_t L1, class T2, index_t L2> inline constexpr bool
    operator>(span<T1, L1> l, span<T2, L2> r)	{ return (r < l); }
    
    template<class T1, index_t L1, class T2, index_t L2> inline constexpr bool
    operator>=(span<T1, L1> l, span<T2, L2> r)	{ return !(l < r); }
    
    • The as_bytes & as_writeable_bytes have a mistake in their disabled lines (closing paren in wrong plac)e: return { reinterpret_cast< std::byte const * >( spn.data(), spn.size_bytes() ) }; should be: return { reinterpret_cast<std::byte const*>(spn.data()), spn.size_bytes() };                                                       ^ And return { reinterpret_cast< std::byte * >( spn.data(), spn.size_bytes() ) }; should be: return { reinterpret_cast<std::byte*>(spn.data()), spn.size_bytes() };                                                 ^
    • I added the following helpers along with the make_span functions:
    template<class T> inline constexpr auto
    byte_span(T& t) noexcept
        { return span<byte, sizeof(t)>(reinterpret_cast<byte*>(&t), sizeof(t)); }
    
    template<class T> inline constexpr auto
    byte_span(T const& t) noexcept
        { return span<byte const, sizeof(t)>(reinterpret_cast<byte const*>(&t), sizeof(t)); }
    
    • I also added cdata, front & back member functions (with the obvious impls).
    • Additionally I added the following (as C++ has no operator===):
        template<class Span2 = span<T, Extent>>
        constexpr bool same(Span2 s) const noexcept
        {
            return static_cast<void const*>(data()) == s.data() && size() == s.size();
        }
    
  • Overly permissive constructor

    Overly permissive constructor

    Hi, we have got a bunch of code in our repository that looks like this (simplified):

    #include "span.hpp"
    #include <cstddef>
    #include <cstdint>
    
    void foo(nonstd::span<std::uint8_t>) {}
    void foo(nonstd::span<nonstd::span<std::uint8_t>>) {}
    
    int main() {
      std::uint8_t u;
      foo({&u, 1u});
      return 0;
    }
    

    I am looking at upgrading our dependency, and while this used to work fine for us previously (using commit 874fa1b14e75d8ad45f28250caeb518687990c70), this no longer works using the release 0.9.0 as the call to foo is now ambiguous.

    $ clang++-12 --std=c++11 span.cc 
    span.cc:10:3: error: call to 'foo' is ambiguous
      foo({&u, 1u});
      ^~~
    span.cc:5:6: note: candidate function
    void foo(nonstd::span<std::uint8_t>) {}
         ^
    span.cc:6:6: note: candidate function
    void foo(nonstd::span<nonstd::span<std::uint8_t>>) {}
         ^
    1 error generated.
    

    This code also seems to work fine with gcc and clang's implementation of std::span, see https://gcc.godbolt.org/z/Y657dh

    We presume this is due to some constructors being overly permissive and participating in overload resolution where they should not, but we have not looked into which particular one is the issue and this is just a hypothesis, so apologies if the title is inaccurate. I haven't checked the standard in detail to understand if this is supposed to work or not, but presume that the ambiguity is due to an oversight rather than by the standard - apologies if that's not the case!

  • index_type ptr_diff

    index_type ptr_diff

    I glanced at p0122r6.pdf and could not find an answer. size() returns a type index_type which is a ptrdiff_t. ptrdiff_t is signed, so for code that does something similar to:

    if ( std::vector::size() != std::span::size() )

    I will get a compiler warning about comparing signed and unsigned. I do not understand why a span size could be negative.

    What is the rational for using ptrdiff_t here? Given that some of span's constructor can accept size_t that means one could create a span with a size bigger than what span::size() could actually return ?

    I understand this has nothing to do with your implementation but was wondering if you had any comment about this. I assume usage of ptrdiff_t is required by math is performed on pointers?

  • depending on string pulls in heavy dependiencies

    depending on string pulls in heavy dependiencies

    Hello,

    I just realized you pulled in dependencies on string + shift operators. I am not really happy about that, as this will add alot of code, especially if you otherwise dont depend on this class, along with heap allocations.

    I can create a pull request, replacing those dependencies with code using std::to_chars or std::sprintf working purely on the stack. This seems to be the better approach to me, would you agree and accept this?

  • Compile errors with clang10 and libc++

    Compile errors with clang10 and libc++

    When trying to use your library with clang10 and libc++ and c++2a I get some compile errors for missing function-like macro span_HAVE. It works with clang9 and libc++ and c++2a though. Godbolt showcasing the issue (against 0.7.0, but errors also relevant on master branch): https://godbolt.org/z/yWWR6Z

    Compile errors:

    
    x86-64 clang 10.0.0 (Editor #1, Compiler #1) C++
    x86-64 clang 10.0.0
    -stdlib=libc++ -std=c++2a
    1
    <Compilation failed>
    x86-64 clang 10.0.0 - 1422ms
    #1 with x86-64 clang 10.0.0
    nonstd/span.hpp:1523:61: error: function-like macro 'span_HAVE' is not defined
    
    #if span_CPP11_OR_GREATER && span_FEATURE( BYTE_SPAN ) && ( span_HAVE( BYTE ) || span_HAVE( NONSTD_BYTE ) )
    
                                                                ^
    
    nonstd/span.hpp:1553:5: error: function-like macro 'span_HAVE' is not defined
    
    #if span_HAVE( STRUCT_BINDING )
    
  • tuple_element is declared as a struct but in the standard library headers it's a class

    tuple_element is declared as a struct but in the standard library headers it's a class

    This results in a compilation warning. https://en.cppreference.com/w/cpp/utility/tuple/tuple_element lists it as a class too. Needs to be changed to class + the forward-declaration in non-C++11 mode.

  • extent_t is ptrdiff_t, which ruins SFINAE for people expecting std::size_t

    extent_t is ptrdiff_t, which ruins SFINAE for people expecting std::size_t

    I wrote a template

    template <typename T, std::size_t Extent>
    void process(span<T, Extent> ...) {
    
    }
    

    This didn't work properly, because extent_t in span-lite is ptrdiff_t. Can I change this to std::size_t and make a PR, or is there a specific reason span-lite made this choice?

  • Failed to build release 0.5.0 with gcc 5.4 and default `-std` setting

    Failed to build release 0.5.0 with gcc 5.4 and default `-std` setting

    Here is the diagnostic:

    [ 50%] Building CXX object CMakeFiles/test_package.dir/test_package.cpp.o
    In file included from /tmp/c3ipr/pr_66_1_0_0/test_package/test_package.cpp:1:0:
    /tmp/c3ipr/pr_66_1_0_0/.conan/data/span-lite/0.5.0/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/nonstd/span.hpp: In function ‘void nonstd::span_lite::detail::throw_out_of_range(nonstd::span_lite::index_t, nonstd::span_lite::index_t)’:
    /tmp/c3ipr/pr_66_1_0_0/.conan/data/span-lite/0.5.0/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/nonstd/span.hpp:614:11: error: ‘out_of_range’ is not a member of ‘std’
         throw std::out_of_range( "span::at(): index outside span" );
    

    More details here: https://github.com/conan-io/conan-center-index/pull/66#issuecomment-533714103

  • Question regarding the design of the extension functions (subspan etc.)

    Question regarding the design of the extension functions (subspan etc.)

    Hello,

    I have a question regarding the design of the free functions:subspan, first and last: As they do not explicitly accept span<T> are they intended to be used with any type that can be accepted by make_span function? If it is the case then the implementation seems to have an issue: as ADL is not finding them with non-span-specialization parameters the call to this functions should be qualified (currently they are not available in the nonstd namespace) and make_span in the trailing return type expression should be visible for non-ADL. Unfortunately the unit-tests cover only the cases where the span specialization is passed to the functions (works because of ADL), so it is not clear if the use-case was considered, although I personally find it to be useful (would be glad to contribute here).

    If the functions are designed to be used with span-s only as wrappers for methods to avoid .template then maybe they could accept span<T> ?

    Could you please clarify the use cases and rational behind the design?

    Thank you.

  • remove dependencies on string,

    remove dependencies on string,

    Add a new config MEMBER_AT_REPORTS_DETAIL, disabled by default. Enabling this config option will result in extended messages for out-of-bounds access

    should be portable aslong index_t is signed and not bigger than a longlong

    see #16

  • Inconsitent behaviors with C array and make_span return type

    Inconsitent behaviors with C array and make_span return type

    Hello, please see the following:

    static_assert(std::is_same<decltype(make_span(std::declval<int[5]>())),span<const int>>::value, "make_span Broken");
    static_assert(std::is_same<decltype(make_span(std::declval<int(&)[5]>())),span<int,5>>::value, "make_span Broken");
    static_assert(std::is_same<decltype(make_span(std::declval<const int[5]>())),span<const int,5>>::value, "make_span Broken");
    static_assert(std::is_same<decltype(make_span(std::declval<const int(&)[5]>())),span<const int,5>>::value, "make_span Broken");
    

    The first case returns a span with dynamic extent, while the other 3 return a span with a fixed size extent.

    While non-const rvalue reference to C arrays almost never appear anywhere, this is a minor inconsistency and looks like a bug?

  • span_FEATURE_*_TO_STD does not do what is advertised

    span_FEATURE_*_TO_STD does not do what is advertised

    Example:

    -Dspan_FEATURE_MAKE_SPAN_TO_STD=14 Define this to the highest C++ language version for which to provide creator functions nonstd::make_span(). Default is undefined.

    1. I do not understand why? It sounds like defining this to "14" leads to make_span available in 98, 11, 14 and not available in 17, 20, ... Why would one want this?
    2. It does not work like that: #define span_IN_STD( v ) ( (v) == 98 || (v) >= span_CPLUSPLUS_V )
    • When defined to 98 it will always be available
    • Otherwise see 1.

    Is this intentional? If so, can this be documented?
    Why not make it simply a ON/OFF define? The build system can then be used to provide those in a more transparent way. (e.g. CMake generator expressions)

  • Specialize span for dynamic extent (optimize static size)

    Specialize span for dynamic extent (optimize static size)

    From issue #3.

    See also libc++ span snippet.

    Note remark by Nevin Liber in [isocpp-lib] Another span question, on 24-Apr-18 22:55:

    Meta-questions: why are we conflating fixed extents and dynamic extents into the same class template? (shades of vector...) And why did this go directly into C++20 instead of Lib Fundamentals?

  • Add various ways for 'installation', such as CMake package

    Add various ways for 'installation', such as CMake package

    Plan

    • [ ] Installation: As copied header
    • [ ] Installation: As external Git project
    • [x] Installation: As CMake package
    • [ ] Installation: As Conan package
string_view lite - A C++17-like string_view for C++98, C++11 and later in a single-file header-only library

string_view lite: A single-file header-only version of a C++17-like string_view for C++98, C++11 and later Contents Example usage In a nutshell Licens

Sep 23, 2022
variant lite - A C++17-like variant, a type-safe union for C++98, C++11 and later in a single-file header-only library

variant lite: A single-file header-only version of a C++17-like variant, a type-safe union for C++98, C++11 and later Contents Example usage In a nuts

Sep 22, 2022
expected lite - Expected objects in C++11 and later in a single-file header-only library

expected lite: expected objects for C++11 and later expected lite is a single-file header-only library for objects that either represent a valid value

Sep 19, 2022
gsl-lite – A single-file header-only version of ISO C++ Guidelines Support Library (GSL) for C++98, C++11, and later

gsl-lite: Guidelines Support Library for C++98, C++11 up metadata build packages try online gsl-lite is an implementation of the C++ Core Guidelines S

Sep 20, 2022
gsl-lite – A single-file header-only version of ISO C++ Guidelines Support Library (GSL) for C++98, C++11, and later

gsl-lite: Guidelines Support Library for C++98, C++11 up metadata build packages try online gsl-lite is an implementation of the C++ Core Guidelines S

Sep 13, 2022
Single-header header-only C++11 / C++14 / C++17 library for easily managing set of auto-generated type-safe flags.
Single-header header-only C++11 / C++14 / C++17 library for easily managing set of auto-generated type-safe flags.

Single-header header-only C++11 / C++14 / C++17 library for easily managing set of auto-generated type-safe flags. Quick start #include <bitflags/bitf

Aug 24, 2022
Libft is an individual project at 42 that requires us to re-create some standard C library functions including some additional ones that can be used later to build a library of useful functions for the rest of the program.

?? Index What is Libft? List of Functions Technologies ✨ What is Libft? Libft is an individual project at 42 that requires us to re-create some standa

Jan 17, 2022
A collection of std-like single-header C++ libraries

itlib: iboB's Template Libraries A collection of small single-header C++ libraries similar to or extending the C++ standard library. See below for a l

Sep 21, 2022
A header-only, unobtrusive, almighty alternative to the C++ switch statement that looks just like the original.

uberswitch A header-only, unobtrusive, almighty alternative to the C++ switch statement that looks just like the original. Sample usage (incomplete -

Sep 7, 2022
jkds is a modern header-only C++20 library that complements the standard library.

jkds is a modern header-only C++20 library that complements the standard library. It provides generic atypical data structures, ergonomic functional programming abstractions, and then some.

May 24, 2022
Bsl - Rust 2018 and C++20, "constexpr everything", AUTOSAR compliant header-only library intended to support the development of critical systems applications
Bsl - Rust 2018 and C++20,

Description The Bareflank Support Library (BSL) is a Rust 2018 and C++20, "constexpr everything", AUTOSAR compliant header-only library intended to su

Sep 13, 2022
Modern C++ generic header-only template library.

nytl A lightweight and generic header-only template library for C++17. Includes various utility of all kind that i needed across multiple projects: Ex

Sep 15, 2022
Lightweight single-file utilities for C99. Portable & zero dependency

plainlibs Lightweight single-file utilities for C99. Key Features Portable across Unix & Windows (including MSVC) Zero dependencies (besides C stdlib)

Aug 28, 2022
Library that simplify to find header for class from STL library.

Library that simplify to find header for class from STL library. Instead of searching header for some class you can just include header with the class name.

Jun 7, 2022
Allows a programmer to print table-like outputs over std::ostream.

tableprinter Allows a programmer to print table-like outputs over std::ostream. It is a header only library. No other dependency than STL. Provides re

Jul 7, 2022
Improved and configurable drop-in replacement to std::function that supports move only types, multiple overloads and more

fu2::function an improved drop-in replacement to std::function Provides improved implementations of std::function: copyable fu2::function move-only fu

Sep 19, 2022
SCST is a SCSI target software stack that allows to export any block device or file via iSCSI, FC or RDMA (SRP).

Overview This is the source code repository of the SCST project. SCST is a collection of Linux kernel drivers that implement SCSI target functionality

Sep 12, 2022
Thrust is a C++ parallel programming library which resembles the C++ Standard Library.

Thrust: Code at the speed of light Thrust is a C++ parallel programming library which resembles the C++ Standard Library. Thrust's high-level interfac

Sep 17, 2022
A template C project using CMAKE, logging library and basic memory handling.

C Project template Aim of this Repository is to create a template repository for C executable projects with following properties: Cmake project Loggin

May 23, 2022