template<class T, class D = void()(T, std::size_t)>
Corrade::Containers::Array class

Array wrapper with size information.

Template parameters
T	Element type
D	Deleter type. Defaults to pointer to `void(T*, std::size_t)` function, where first is array pointer and second array size

Array initialization
Wrapping externally allocated arrays
Reference

Provides movable RAII wrapper around plain C array. Main use case is storing binary data of unspecified type, where addition/removal of elements is not needed or harmful.

However, the class is usable also as a lighter non-copyable alternative to std::vector; usable in STL algorithms in the same way as plain C array and additionally also in range-for cycle.

Usage example:

// Create default-initialized array with 5 integers and set them to some value
Containers::Array<int> a{5};
int b = 0;
for(auto& i: a) i = b++; // a = {0, 1, 2, 3, 4}

// Create array from given values
auto b = Containers::Array<int>::from(3, 18, -157, 0);
b[3] = 25; // b = {3, 18, -157, 25}

Array initialization

The array is by default default-initialized, which means that trivial types are not initialized at all and default constructor is called on other types. It is possible to initialize the array in a different way using so-called tags:

Array(DefaultInitT, std::size_t) is equivalent to the default case (useful when you want to make the choice appear explicit).
Array(ValueInitT, std::size_t) zero-initializes trivial types and calls default constructor elsewhere.
Array(DirectInitT, std::size_t, Args&&... args) constructs all elements of the array using provided arguments.
Array(NoInitT, std::size_t) does not initialize anything and you need to call the constructor on all elements manually using placement new, std::uninitialized_copy() or similar. This is the dangerous option.

Example:

// These are equivalent
Containers::Array<int> a1{5};
Containers::Array<int> a2{Containers::DefaultInit, 5};

// Array of 100 zeros
Containers::Array<int> b{Containers::ValueInit, 100};

// Array of type with no default constructor
struct Vec3 {
    Vec3(float, float, float);
};
Containers::Array<Vec3> c{Containers::DirectInit, 5, 5.2f, 0.4f, 1.0f};

// Manual construction of each element
struct Foo {
    Foo(int index);
};
Containers::Array<Foo> d{Containers::NoInit, 5};
int index = 0;
for(Foo& f: d) new(&f) Foo(index++);

Wrapping externally allocated arrays

By default the class makes all allocations using operator new[] and deallocates using operator delete[] for given T, with some additional trickery done internally to make the Array(NoInitT, std::size_t) and Array(DirectInitT, std::size_t, Args&&... args) constructors work. When wrapping an externally allocated array using Array(T*, std::size_t, D), it is possible to specify which function to use for deallocation. By default the deleter is set to nullptr, which is equivalent to deleting the contents using operator delete[].

For example, properly deallocating array allocated using std::malloc():

const int* data = reinterpret_cast<int*>(std::malloc(25*sizeof(int)));

// Will call std::free() on destruction
Containers::Array<int> array{data, 25, [](int* data, std::size_t) { std::free(data); }};

By default, plain function pointers are used to avoid having the type affected by the deleter function. If the deleter needs to manage some state, a custom deleter type can be used:

struct UnmapBuffer {
    UnmapBuffer(GLuint id): _id{id} {}
    void operator()(T*, std::size_t) { glUnmapNamedBuffer(_id); }

private:
    GLuint _id;
};

GLuint buffer;
char* data = reinterpret_cast<char*>(glMapNamedBuffer(buffer, GL_READ_WRITE));

// Will unmap the buffer on destruction
Containers::Array<char, UnmapBuffer> array{data, bufferSize, UnmapBuffer{buffer}};

Public types

using Type = T: Element type.
using Deleter = D: Deleter type.

Public static functions

template<class ... U> static auto from(U&&... values) -> Array<T, D> deprecated: Construct list-initialized array.
static auto zeroInitialized(std::size_t size) -> Array<T, D> deprecated: Construct value-initialized array.

Constructors, destructors, conversion operators

Array(std::nullptr_t) noexcept: Conversion from nullptr.
Array() noexcept: Default constructor.
Array(DefaultInitT, std::size_t size) explicit: Construct default-initialized array.
Array(ValueInitT, std::size_t size) explicit: Construct value-initialized array.
Array(NoInitT, std::size_t size) explicit: Construct the array without initializing its contents.
template<class... Args> Array(DirectInitT, std::size_t size, Args&&... args) explicit: Construct direct-initialized array.
Array(InPlaceInitT, std::initializer_list<T> list) explicit: Construct list-initialized array.
Array(std::size_t size) explicit: Construct default-initialized array.
Array(T* data, std::size_t size, D deleter = Implementation::DefaultDeleter<D>{}()) explicit: Wrap existing array.
Array(const Array<T, D>&) deleted: Copying is not allowed.
Array(Array<T, D>&& other) noexcept: Move constructor.
operator bool() const explicit: Whether the array is non-empty.
template<class U> operator ArrayView<U>() noexcept: Convert to ArrayView.
template<class U> operator ArrayView<const U>() const noexcept: Convert to const ArrayView.
operator ArrayView<const void>() const noexcept
operator T*() &: Conversion to array type.
operator const T*() const &

Public functions

auto operator=(const Array<T, D>&) -> Array<T, D>& deleted: Copying is not allowed.
auto operator=(Array<T, D>&&) -> Array<T, D>& noexcept: Move assignment.
auto data() -> T*: Array data.
auto data() const -> const T*
auto deleter() const -> D: Array deleter.
auto size() const -> std::size_t: Array size.
auto empty() const -> bool: Whether the array is empty.
auto begin() -> T*: Pointer to first element.
auto begin() const -> const T*
auto cbegin() const -> const T*
auto end() -> T*: Pointer to (one item after) last element.
auto end() const -> const T*
auto cend() const -> const T*
auto slice(T* begin, T* end) -> ArrayView<T>: Reference to array slice.
auto slice(const T* begin, const T* end) const -> ArrayView<const T>
auto slice(std::size_t begin, std::size_t end) -> ArrayView<T>
auto slice(std::size_t begin, std::size_t end) const -> ArrayView<const T>
template<std::size_t size> auto slice(T* begin) -> StaticArrayView<size, T>: Fixed-size array slice.
template<std::size_t size> auto slice(const T* begin) const -> StaticArrayView<size, const T>
template<std::size_t size> auto slice(std::size_t begin) -> StaticArrayView<size, T>
template<std::size_t size> auto slice(std::size_t begin) const -> StaticArrayView<size, const T>
auto prefix(T* end) -> ArrayView<T>: Array prefix.
auto prefix(const T* end) const -> ArrayView<const T>
auto prefix(std::size_t end) -> ArrayView<T>
auto prefix(std::size_t end) const -> ArrayView<const T>
auto suffix(T* begin) -> ArrayView<T>: Array suffix.
auto suffix(const T* begin) const -> ArrayView<const T>
auto suffix(std::size_t begin) -> ArrayView<T>
auto suffix(std::size_t begin) const -> ArrayView<const T>
auto release() -> T*: Release data storage.

Function documentation

template<class T, class D> template<class ... U>
static Array<T, D> Corrade::Containers::Array<T, D>::from(U&&... values)

Construct list-initialized array.

template<class T, class D>
static Array<T, D> Corrade::Containers::Array<T, D>::zeroInitialized(std::size_t size)

Construct value-initialized array.

template<class T, class D>
Corrade::Containers::Array<T, D>::Array() noexcept

Default constructor.

Creates zero-sized array. Move array with nonzero size onto the instance to make it useful.

template<class T, class D>
Corrade::Containers::Array<T, D>::Array(DefaultInitT, std::size_t size) explicit

Construct default-initialized array.

Creates array of given size, the contents are default-initialized (i.e. builtin types are not initialized). If the size is zero, no allocation is done.

template<class T, class D>
Corrade::Containers::Array<T, D>::Array(ValueInitT, std::size_t size) explicit

Construct value-initialized array.

Creates array of given size, the contents are value-initialized (i.e. builtin types are zero-initialized). For other than builtin types this is the same as Array(std::size_t). If the size is zero, no allocation is done.

Useful if you want to create an array of primitive types and sett them to zero.

template<class T, class D>
Corrade::Containers::Array<T, D>::Array(NoInitT, std::size_t size) explicit

Construct the array without initializing its contents.

Creates array of given size, the contents are not initialized. If the size is zero, no allocation is done. Initialize the values using placement new.

Useful if you will be overwriting all elements later anyway.

template<class T, class D> template<class... Args>
Corrade::Containers::Array<T, D>::Array(DirectInitT, std::size_t size, Args&&... args) explicit

Construct direct-initialized array.

Allocates the array using the Array(NoInitT, std::size_t) constructor and then initializes each element with placement new using forwarded args.

template<class T, class D>
Corrade::Containers::Array<T, D>::Array(InPlaceInitT, std::initializer_list<T> list) explicit

Construct list-initialized array.

Allocates the array using the Array(NoInitT, std::size_t) constructor and then copy-initializes each element with placement new using values from list.

template<class T, class D>
Corrade::Containers::Array<T, D>::Array(std::size_t size) explicit

Construct default-initialized array.

Alias to Array(DefaultInitT, std::size_t).

template<class T, class D>
Corrade::Containers::Array<T, D>::Array(T* data, std::size_t size, D deleter = Implementation::DefaultDeleter<D>{}()) explicit

Wrap existing array.

Note that the array will be deleted on destruction using given deleter. See class documentation for more information about custom deleters and ArrayView for non-owning array wrapper.

template<class T, class D> template<class U>
Corrade::Containers::Array<T, D>::operator ArrayView<U>() noexcept

Convert to ArrayView.

Enabled only if T* is implicitly convertible to U*. Expects that both types have the same size.

template<class T, class D> template<class U>
Corrade::Containers::Array<T, D>::operator ArrayView<const U>() const noexcept

Convert to const ArrayView.

Enabled only if T* or const T* is implicitly convertible to U*. Expects that both types have the same size.