class array_ref<T> meta¶

using value_type             = T

using pointer                = value_type*

using const_pointer          = const value_type*

using reference              = value_type&

using const_reference        = const value_type&

using iterator               = pointer

using const_iterator         = const_pointer

using reverse_iterator       = std::reverse_iterator<pointer>

using const_reverse_iterator = std::reverse_iterator<const_iterator>

using size_type              = std::size_t

using difference_type        = std::ptrdiff_t

constexpr array_ref() noexcept : m_data(nullptr), m_size(0) { … }

constexpr array_ref(const array_ref&) noexcept            = default

constexpr array_ref(array_ref&&) noexcept                 = default

constexpr array_ref& operator=(const array_ref&) noexcept = default

constexpr array_ref& operator=(array_ref&&) noexcept      = default

template <has_data_size Container>
array_ref(Container&& cont)

constexpr array_ref(std::initializer_list<T> vec) noexcept : m_data(vec.begin()), m_size(vec.size()) { … }

constexpr array_ref(T* data, size_type size) noexcept : m_data(data), m_size(size) { … }

constexpr reference front() const noexcept { … }

constexpr reference back() const noexcept { … }

constexpr iterator begin() const noexcept { … }

constexpr iterator end() const noexcept { … }

constexpr const_iterator cbegin() const noexcept { … }

constexpr const_iterator cend() const noexcept { … }

constexpr pointer data() const noexcept { … }

constexpr std::size_t size() const noexcept { … }

constexpr bool empty() const noexcept { … }

constexpr reference operator[](std::size_t index) const { … }