dynarray.hh

Go to the documentation of this file.

#ifndef DYNARRAY_HH
#define DYNARRAY_HH
 
// dynarray -- this models a dynamically sized array.
// This falls between a std::array and a std::vector.
//
// - Like vector the size of a dynarray is set at run-time (for std::array it's
//   set during compile-time).
// - Unlike vector the size of a dynarray can no longer change (grow/shrink)
//   after the initial construction.
//
// So qua functionality dynarray can do strictly less than a vector and strictly
// more than an array.
//
// The (only?) advantage of dynarray over vector is that the size of the
// dynarray itself is slightly smaller than the size of a vector (vector
// additionally needs to store the capacity; for dynarray size and capacity are
// always the same). (Typically on a 64-bit system: sizeof(vector)=24 and
// sizeof(dynarray)=16).
//
// This class is very similar to the array-version of std::unique_ptr (in fact
// the current implementation is based on unique_ptr<T[]>). The only addition is
// that dynarray also stores the size(*).
// (*) Technically, I think, unique_ptr<T[]> already stores the size internally
//     (typically at some offset in the allocated block). Though unfortunately
//     there's no portable way to access this size. So storing the size in the
//     dynarray class is necessary but strictly speaking redundant.
//
// The name and the interface of this class is based on the std::dynarray
// proposal for c++14. Though that proposal did not make it in c++14 and seems
// to be abandoned. Here's some (old) documentation:
//     https://www.enseignement.polytechnique.fr/informatique/INF478/docs/Cpp/en/cpp/container/dynarray.html
// This is not a full implementation of that proposal, just the easy parts
// and/or the parts that we currently need. Can easily be extended in the future
// (when needed).
 
#include <cassert>
#include <memory>
 
template<typename T>
class dynarray
{
public:
        dynarray() = default;
        dynarray(const dynarray&) = delete;
        dynarray& operator=(const dynarray&) = delete;
        ~dynarray() = default;
 
        explicit dynarray(size_t n)
                : m_size(n), m_data(std::make_unique<T[]>(n)) {}
 
        dynarray(size_t n, const T& value)
                : m_size(n), m_data(std::make_unique<T[]>(n, value)) {}
 
        struct construct_from_range_tag {};
        template<typename SizedRange>
        dynarray(construct_from_range_tag, SizedRange&& range)
                : m_size(std::size(range)), m_data(std::make_unique<T[]>(m_size)) {
                size_t i = 0;
                for (const auto& e : range) {
                        m_data[i] = e;
                        ++i;
                }
        }
 
        dynarray(dynarray&& other) noexcept
                : m_size(other.m_size), m_data(std::move(other.m_data)) {
                other.m_size = 0;
                assert(!other.m_data);
        }
 
        dynarray& operator=(dynarray&& other) noexcept {
                if (this == &other) return *this;
                m_size = other.m_size;
                m_data = std::move(other.m_data);
                assert(!other.m_data);
                return *this;
        }
 
        [[nodiscard]] T& operator[](size_t i) {
                assert(i < m_size);
                return m_data[i];
        }
        [[nodiscard]] const T& operator[](size_t i) const {
                assert(i < m_size);
                return m_data[i];
        }
 
        [[nodiscard]] T& front() {
                assert(!empty());
                return m_data[0];
        }
        [[nodiscard]] const T& front() const {
                assert(!empty());
                return m_data[0];
        }
        [[nodiscard]] T& back() {
                assert(!empty());
                return m_data[m_size - 1];
        }
        [[nodiscard]] const T& back() const {
                assert(!empty());
                return m_data[m_size - 1];
        }
 
        [[nodiscard]] T* data() { return m_data.get(); }
        [[nodiscard]] const T* data() const { return m_data.get(); }
 
        [[nodiscard]] T* begin() { return m_data.get(); }
        [[nodiscard]] const T* begin() const { return m_data.get(); }
        [[nodiscard]] T* end() { return m_data.get() + m_size; }
        [[nodiscard]] const T* end() const { return m_data.get() + m_size; }
 
        [[nodiscard]] bool empty() const { return m_size == 0; }
        [[nodiscard]] size_t size() const { return m_size; }
 
private:
        size_t m_size = 0;
        std::unique_ptr<T[]> m_data;
};
 
#endif