xte::array {}

Definition

template<typename T>
struct array {
	using size_type = xte::uz;
	using difference_type = xte::iptrdiff;
	using value_type = T;
	using reference = T&;
	using const_reference = const T&;
	using pointer = T*;
	using const_pointer = const T*;
	using iterator = T*;
	using const_iterator = const T*;
	using reverse_iterator = std::reverse_iterator<T*>;
	using const_reverse_iterator = std::reverse_iterator<const T*>;
	using allocator_type = std::allocator<T>;

	explicit(false) constexpr array() noexcept = default;
	
	explicit(false) constexpr array(const xte::array<T>&) noexcept(false) requires(/* ... */);

	explicit(false) constexpr array(xte::array<T>&&) noexcept;

	explicit(false) constexpr array(xte::init_list<T>) noexcept(false);

	template<std::ranges::input_range Range>
	explicit constexpr array(std::from_range_t, Range&&) noexcept(false) requires(/* ... */);

	template<std::input_iterator Iter>
	constexpr array(Iter, std::sentinel_for<Iter> auto) XTE_ARROW_CTOR(/* ... */)

	explicit constexpr array(xte::uz) noexcept(false);

	constexpr array(xte::uz, const T&) noexcept(false);

	constexpr ~array();

	constexpr xte::array<T>& operator=(const xte::array<T>&) & noexcept(false) requires(/* ... */);

	constexpr xte::array<T>& operator=(xte::array<T>&&) & noexcept;

	template<std::ranges::input_range Range>
	constexpr xte::array<T>& operator=(Range&&) & noexcept(false) requires(/* ... */);

	constexpr auto* data(this auto&&) noexcept;

	constexpr xte::uz size() const noexcept;

	constexpr xte::uz capacity() const noexcept;

	friend constexpr auto operator<=>(const xte::array<T>&, const xte::array<T>&) XTE_ARROW(/* ... */)

	friend constexpr auto operator==(const xte::array<T>&, const xte::array<T>&) XTE_ARROW(/* ... */)

	constexpr auto* begin(this auto&&) noexcept;
	
	constexpr const T* cbegin() const noexcept;

	constexpr auto* end(this auto&&) noexcept;
	
	constexpr const T* cend() const noexcept;

	constexpr auto rbegin(this auto&&) noexcept;

	constexpr auto crbegin() const noexcept;

	constexpr auto rend(this auto&&) noexcept;

	constexpr auto crend() const noexcept;

	constexpr auto&& front(this auto&&, xte::uz) noexcept;

	constexpr auto&& back(this auto&&, xte::uz) noexcept;

	constexpr auto&& operator[](this auto&&, xte::uz) noexcept;

	constexpr xte::array<T> slice(xte::uz, xte::uz) const noexcept(false);

	constexpr void reset() & noexcept;

	constexpr void resize(xte::uz) & noexcept(false);
	
	constexpr void resize(xte::uz, const T&) & noexcept(false);

	constexpr void reserve(xte::uz) & noexcept(false) requires(/* ... */);

	constexpr void reserve_total(xte::uz) & noexcept(false) requires(/* ... */);

	constexpr void shrink() & noexcept(false) requires(/* ... */);

	constexpr void insert_uninit(xte::uz, xte::uz) & noexcept(false);

	constexpr void insert(xte::uz) & noexcept(false);
	
	template<typename U = T>
	constexpr void insert(xte::uz, U&&, auto&&...) & noexcept(false);

	template<std::ranges::input_range Range = xte::array<T>>
	constexpr void insert_range(xte::uz, Range&&) & noexcept(false) requires(/* ... */);

	constexpr void erase(xte::uz, xte::uz) & noexcept;

	constexpr auto push(xte::uz, xte::uz) & XTE_ARROW(/* ... */)
	
	template<typename U = T>
	constexpr auto push(U&&, auto&&...) & XTE_ARROW(/* ... */)

	template<typename Range = xte::array<T>>
	constexpr auto push_range(Range&&) & XTE_ARROW(/* ... */)

	constexpr T pop() & noexcept(/* ... */) requires(/* ... */);

	friend constexpr auto operator+(xte::is_derived_from<xte::array<T>> auto&&, auto&&) XTE_ARROW(/* ... */)

	template<typename Lhs>
	requires(/* ... */)
	friend constexpr auto operator+(Lhs&&, xte::is_derived_from<xte::array<T>> auto) XTE_ARROW(/* ... */)

	constexpr auto operator+=(this auto&&, auto&&) XTE_ARROW(/* ... */)
};

Deduction guide

template<typename T, typename... Ts>
array(T&, Ts&&...) -> array<std::common_type_t<T, Ts...>>;

Example

xte::array array = { 1, 2, 3 };
std::println("{}", array);

[1, 2, 3]