vector.h

Go to the documentation of this file.

 
#ifndef VECTOR_H
#define VECTOR_H
 
#include <cstddef>
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <memory>
 
namespace dsa
{

    template<typename T>
    class Vector
    {
    public:

        using value_type = T;

        using allocator_type = std::allocator<value_type>;

        using size_type = std::size_t;

        using difference_type = std::ptrdiff_t;

        using pointer = T*;

        using const_pointer = const T*;

        using reference = T&;

        using const_reference = const T&;

        using iterator = T*;

        using const_iterator = const T*;

        using reverse_iterator = std::reverse_iterator<iterator>;

        using const_reverse_iterator = std::reverse_iterator<const_iterator>;

        constexpr Vector();

        constexpr Vector(size_type count);

        constexpr Vector(size_type count, const T& value);

        template<typename InputIt>
            requires std::input_iterator<InputIt>
        constexpr Vector(InputIt first, InputIt last);

        constexpr Vector(const Vector<T>& other);

        constexpr Vector(Vector<T>&& other) noexcept;

        constexpr Vector(std::initializer_list<T> init_list);

        ~Vector();

        constexpr auto operator=(const Vector<T>& other) -> Vector<T>&;

        constexpr auto operator=(Vector<T>&& other) noexcept -> Vector<T>&;

        constexpr auto operator=(std::initializer_list<T> init_list) -> Vector<T>&;

        constexpr void assign(size_type count, const T& value);

        template<typename InputIt>
            requires std::input_iterator<InputIt>
        // do not use `last` as const reference to keep arguments the same as in std
        // NOLINTNEXTLINE(performance-unnecessary-value-param)
        constexpr void assign(InputIt first, InputIt last);

        constexpr void assign(std::initializer_list<T> init_list);

        [[nodiscard]] constexpr auto get_allocator() const -> allocator_type;

        [[nodiscard]] constexpr auto at(size_type pos) -> reference;

        [[nodiscard]] constexpr auto at(size_type pos) const -> const_reference;

        [[nodiscard]] constexpr auto operator[](size_type pos)->reference;

        [[nodiscard]] constexpr auto operator[](size_type pos) const->const_reference;

        [[nodiscard]] constexpr auto front() -> reference;

        [[nodiscard]] constexpr auto front() const -> const_reference;

        [[nodiscard]] constexpr auto back() -> reference;

        [[nodiscard]] constexpr auto back() const -> const_reference;

        [[nodiscard]] constexpr auto data() noexcept -> pointer;

        [[nodiscard]] constexpr auto data() const noexcept -> const_pointer;

        [[nodiscard]] constexpr auto begin() noexcept -> iterator;

        [[nodiscard]] constexpr auto begin() const noexcept -> const_iterator;

        [[nodiscard]] constexpr auto cbegin() const noexcept -> const_iterator;

        [[nodiscard]] constexpr auto end() noexcept -> iterator;

        [[nodiscard]] constexpr auto end() const noexcept -> const_iterator;

        [[nodiscard]] constexpr auto cend() const noexcept -> const_iterator;

        [[nodiscard]] constexpr auto rbegin() -> reverse_iterator;

        [[nodiscard]] constexpr auto rbegin() const -> const_reverse_iterator;

        [[nodiscard]] constexpr auto crbegin() const noexcept -> const_reverse_iterator;

        [[nodiscard]] constexpr auto rend() -> reverse_iterator;

        [[nodiscard]] constexpr auto rend() const -> const_reverse_iterator;

        [[nodiscard]] constexpr auto crend() const noexcept -> const_reverse_iterator;

        [[nodiscard]] constexpr auto empty() const -> bool;

        [[nodiscard]] constexpr auto size() const noexcept -> size_type;

        [[nodiscard]] constexpr auto max_size() const noexcept -> size_type;

        constexpr void reserve(size_type new_cap);

        constexpr auto capacity() -> size_type;

        constexpr void shrink_to_fit();

        constexpr void clear();

        constexpr auto insert(const_iterator pos, const T& value) -> iterator;

        constexpr auto insert(const_iterator pos, T&& value) -> iterator;

        constexpr auto insert(const_iterator pos, size_type count, const T& value) -> iterator;

        template<typename InputIt>
            requires std::input_iterator<InputIt>
        constexpr auto insert(const_iterator pos, InputIt first, InputIt last) -> iterator;

        constexpr auto insert(const_iterator pos, std::initializer_list<T> init_list) -> iterator;

        template<typename... Args>
        constexpr auto emplace(const_iterator pos, Args&&... args) -> iterator;

        template<typename... Args>
        constexpr auto emplace_back(Args&&... args) -> reference;

        constexpr auto erase(iterator pos) -> iterator;

        constexpr auto erase(const_iterator pos) -> iterator;

        constexpr auto erase(iterator first, iterator last) -> iterator;

        constexpr auto erase(const_iterator first, const_iterator last) -> iterator;

        constexpr void push_back(const T& value);

        constexpr void push_back(T&& value);

        constexpr void pop_back();

        constexpr void resize(size_type count);

        constexpr void resize(size_type count, const value_type& value);

        constexpr void swap(Vector<T>& other) noexcept;
 
    private:

        auto calc_new_capacity() -> size_type;

        auto insert_make_space_for_new_elems(const_iterator pos, size_type count) -> iterator;

        void reallocate(size_type new_cap);

        void destroy_elements();

        void clear_allocation();

        value_type* m_data{};

        size_type m_size{};

        size_type m_capacity{};

        allocator_type m_allocator{};
    };
 
    template<typename T>
    constexpr Vector<T>::Vector() = default;
 
    template<typename T>
    constexpr Vector<T>::Vector(size_type count)
        : Vector(count, T())
    {
    }
 
    template<typename T>
    constexpr Vector<T>::Vector(size_type count, const T& value)
    {
        for (size_t i = 0; i < count; i++)
        {
            push_back(value);
        }
    }
 
    template<typename T>
    template<typename InputIt>
        requires std::input_iterator<InputIt>
    constexpr Vector<T>::Vector(InputIt first, InputIt last)
    {
        // do not use const reference to keep arguments the same as in std
        // NOLINTNEXTLINE(performance-unnecessary-value-param)
        assign(first, last);
    }
 
    template<typename T>
    constexpr Vector<T>::Vector(const Vector<T>& other)
    {
        reserve(other.size());
        for (const auto& item : other)
        {
            push_back(item);
        }
    }
 
    template<typename T>
    constexpr Vector<T>::Vector(Vector<T>&& other) noexcept
    {
        operator=(std::move(other));
    }
 
    template<typename T>
    constexpr Vector<T>::Vector(std::initializer_list<T> init_list)
    {
        assign(init_list);
    }
 
    template<typename T>
    Vector<T>::~Vector()
    {
        clear_allocation();
    }
 
    template<typename T>
    constexpr auto Vector<T>::operator=(const Vector<T>& other) -> Vector<T>&
    {
        if (&other != this)
        {
            clear_allocation();
            m_capacity = 0;
            m_size = 0;
 
            m_data = allocator_type().allocate(other.size());
            for (const auto& item : other)
            {
                push_back(item);
            }
        }
 
        return *this;
    }
 
    template<typename T>
    constexpr auto Vector<T>::operator=(Vector<T>&& other) noexcept -> Vector<T>&
    {
        if (&other != this)
        {
            clear_allocation();
 
            m_data = other.m_data;
            m_capacity = other.m_capacity;
            m_size = other.m_size;
 
            other.m_data = nullptr;
            other.m_capacity = 0;
            other.m_size = 0;
        }
 
        return *this;
    }
 
    template<typename T>
    constexpr auto Vector<T>::operator=(std::initializer_list<T> init_list) -> Vector<T>&
    {
        clear_allocation();
        m_capacity = 0;
        m_size = 0;
 
        m_data = allocator_type().allocate(init_list.size());
        for (auto const& item : init_list)
        {
            push_back(item);
        }
 
        return *this;
    }
 
    template<typename T>
    constexpr void Vector<T>::assign(size_type count, const T& value)
    {
        clear_allocation();
        m_capacity = 0;
        m_size = 0;
 
        m_data = allocator_type().allocate(count);
        for (size_t i = 0; i < count; i++)
        {
            push_back(value);
        }
    }
 
    template<typename T>
    template<typename InputIt>
        requires std::input_iterator<InputIt>
    // do not use `last` as const reference to keep arguments the same as in std
    // NOLINTNEXTLINE(performance-unnecessary-value-param)
    constexpr void Vector<T>::assign(InputIt first, InputIt last)
    {
        const auto count = static_cast<size_type>(std::distance(first, last));
 
        clear_allocation();
        m_capacity = 0;
        m_size = 0;
 
        m_data = allocator_type().allocate(count);
        while (first != last)
        {
            push_back(*first);
            first++;
        }
    }
 
    template<typename T>
    constexpr void Vector<T>::assign(std::initializer_list<T> init_list)
    {
        clear_allocation();
        m_capacity = 0;
        m_size = 0;
 
        m_data = allocator_type().allocate(init_list.size());
        for (auto const& item : init_list)
        {
            push_back(item);
        }
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::get_allocator() const -> allocator_type
    {
        return m_allocator;
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::at(size_type pos) -> reference
    {
        if (pos >= m_size)
        {
            throw std::out_of_range("Pos argument outside of container range");
        }
 
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return m_data[pos];
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::at(size_type pos) const -> const_reference
    {
        if (pos >= m_size)
        {
            throw std::out_of_range("Pos argument outside of container range");
        }
 
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return m_data[pos];
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::operator[](size_type pos) -> reference
    {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return m_data[pos];
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::operator[](size_type pos) const -> const_reference
    {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return m_data[pos];
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::front() -> reference
    {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return m_data[0];
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::front() const -> const_reference
    {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return m_data[0];
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::back() -> reference
    {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return m_data[m_size - 1];
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::back() const -> const_reference
    {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return m_data[m_size - 1];
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::data() noexcept -> pointer
    {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return &m_data[0];
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::data() const noexcept -> const_pointer
    {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return &m_data[0];
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::begin() noexcept -> iterator
    {
        return m_data;
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::begin() const noexcept -> const_iterator
    {
        return m_data;
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::cbegin() const noexcept -> const_iterator
    {
        return m_data;
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::end() noexcept -> iterator
    {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return m_data + m_size;
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::end() const noexcept -> const_iterator
    {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return m_data + m_size;
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::cend() const noexcept -> const_iterator
    {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return m_data + m_size;
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::rbegin() -> reverse_iterator
    {
        return reverse_iterator(end());
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::rbegin() const -> const_reverse_iterator
    {
        return const_reverse_iterator(end());
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::crbegin() const noexcept -> const_reverse_iterator
    {
        return const_reverse_iterator(end());
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::rend() -> reverse_iterator
    {
        return reverse_iterator(begin());
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::rend() const -> const_reverse_iterator
    {
        return const_reverse_iterator(begin());
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::crend() const noexcept -> const_reverse_iterator
    {
        return const_reverse_iterator(begin());
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::empty() const -> bool
    {
        return m_size == 0;
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::size() const noexcept -> size_type
    {
        return m_size;
    }
 
    template<typename T>
    [[nodiscard]] constexpr auto Vector<T>::max_size() const noexcept -> size_type
    {
        return std::allocator_traits<allocator_type>::max_size(get_allocator());
    }
 
    template<typename T>
    constexpr void Vector<T>::reserve(size_type new_cap)
    {
        if (new_cap > capacity())
        {
            // strong exception guarantee by reallocate
            reallocate(new_cap);
        }
    }
 
    template<typename T>
    constexpr auto Vector<T>::capacity() -> size_type
    {
        return m_capacity;
    }
 
    template<typename T>
    constexpr void Vector<T>::shrink_to_fit()
    {
        if (m_capacity > m_size)
        {
            reallocate(m_size);
        }
    }
 
    template<typename T>
    constexpr void Vector<T>::clear()
    {
        destroy_elements();
        m_size = 0;
    }
 
    template<typename T>
    constexpr auto Vector<T>::insert(const_iterator pos, const T& value) -> iterator
    {
        return insert(pos, 1, value);
    }
 
    template<typename T>
    constexpr auto Vector<T>::insert(const_iterator pos, T&& value) -> iterator
    {
        return insert(pos, 1, std::move(value));
    }
 
    template<typename T>
    constexpr auto Vector<T>::insert(const_iterator pos, size_type count, const T& value) -> iterator
    {
        iterator new_pos{ insert_make_space_for_new_elems(pos, count) };
 
        // create objects in range [pos, pos + count]
        iterator new_iter{ new_pos };
        for (size_t i = 0; i < count; i++)
        {
            std::allocator_traits<allocator_type>::construct(m_allocator, new_iter, value);
            ++new_iter;
        }
 
        return new_pos;
    }
 
    template<typename T>
    template<typename InputIt>
        requires std::input_iterator<InputIt>
    constexpr auto Vector<T>::insert(const_iterator pos, InputIt first, InputIt last) -> iterator
    {
        const auto count = static_cast<size_type>(std::distance(first, last));
        iterator new_pos{ insert_make_space_for_new_elems(pos, count) };
 
        // create objects in range [pos, pos + count]
        iterator new_iter{ new_pos };
        while (first != last)
        {
            std::allocator_traits<allocator_type>::construct(m_allocator, new_iter, *first);
            ++new_iter;
            ++first;
        }
 
        return new_pos;
    }
 
    template<typename T>
    constexpr auto Vector<T>::insert(const_iterator pos, std::initializer_list<T> init_list) -> iterator
    {
        const size_type count = init_list.size();
        iterator new_pos{ insert_make_space_for_new_elems(pos, count) };
 
        // create objects in range [pos, pos + count]
        iterator new_iter{ new_pos };
        for (const auto& value : init_list)
        {
            std::allocator_traits<allocator_type>::construct(m_allocator, new_iter, value);
            ++new_iter;
        }
 
        return new_pos;
    }
 
    template<typename T>
    template<typename... Args>
    constexpr auto Vector<T>::emplace(const_iterator pos, Args&&... args) -> iterator
    {
        iterator new_pos{ insert_make_space_for_new_elems(pos, 1) };
 
        // emplace new element
        std::allocator_traits<allocator_type>::construct(m_allocator, new_pos, std::forward<Args>(args)...);
 
        return new_pos;
    }
 
    template<typename T>
    template<typename... Args>
    constexpr auto Vector<T>::emplace_back(Args&&... args) -> reference
    {
        /*
        * If an exception is thrown for any reason, this function has no effect
        * strong exception guarantee by:
        * - reallocate
        * - if construction of new element fails, state of object does not change
        */
 
        if (m_size >= m_capacity)
        {
            reallocate(calc_new_capacity());
        }
        std::allocator_traits<allocator_type>::construct(m_allocator, end(), std::forward<Args>(args)...);
        ++m_size;
 
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        return m_data[m_size - 1];
    }
 
    template<typename T>
    constexpr auto Vector<T>::erase(iterator pos) -> iterator
    {
        return erase(pos, pos + 1);
    }
 
    template<typename T>
    constexpr auto Vector<T>::erase(const_iterator pos) -> iterator
    {
        return erase(pos, pos + 1);
    }
 
    template<typename T>
    constexpr auto Vector<T>::erase(iterator first, iterator last) -> iterator
    {
        return erase(static_cast<const_iterator>(first), static_cast<const_iterator>(last));
    }
 
    template<typename T>
    constexpr auto Vector<T>::erase(const_iterator first, const_iterator last) -> iterator
    {
        const auto offset_last = static_cast<size_type>(last - cbegin());
        const auto offset_first = static_cast<size_type>(first - cbegin());
        const size_type count{ offset_last - offset_first };
 
        // destroy objects in range [first, last)
        while (first != last)
        {
            std::allocator_traits<allocator_type>::destroy(m_allocator, first);
            ++first;
        }
 
        // move remaining objects into empty space
        // this moves memory in range [last, end()] to addres pointed by `first`, that was already released
        std::move(begin() + offset_last, end(), begin() + offset_first);
 
        m_size -= count;
        return begin() + offset_first;
    }
 
    template<typename T>
    constexpr void Vector<T>::push_back(const T& value)
    {
        if (m_size >= m_capacity)
        {
            reallocate(calc_new_capacity());
        }
 
        std::allocator_traits<allocator_type>::construct(m_allocator, end(), value);
        ++m_size;
    }
 
    template<typename T>
    constexpr void Vector<T>::push_back(T&& value)
    {
        // Some implementations throw std::lengt_error when push_back causes a reallocation that exceeds mas_size()
        if (m_size >= m_capacity)
        {
            reallocate(calc_new_capacity());
        }
 
        std::allocator_traits<allocator_type>::construct(m_allocator, end(), std::move(value));
        ++m_size;
    }
 
    template<typename T>
    constexpr void Vector<T>::pop_back()
    {
        if (m_size > 0)
        {
            std::allocator_traits<allocator_type>::destroy(m_allocator, end());
            --m_size;
        }
    }
 
    template<typename T>
    constexpr void Vector<T>::resize(size_type count)
    {
        resize(count, T{});
    }
 
    template<typename T>
    constexpr void Vector<T>::resize(size_type count, const value_type& value)
    {
        if (count >= max_size())
        {
            throw std::length_error("Capacity required by new vector would exceed maximum allowed size");
        }
 
        if (count == m_size)
        {
            return;
        }
 
        if (m_size > count)
        {
            // container is reduced to its count elements
            while (m_size > count)
            {
                pop_back();
            }
        }
 
        if (m_size < count)
        {
            // additional copies of value are appended
            while (m_size < count)
            {
                push_back(value);
            }
        }
    }
 
    template<typename T>
    constexpr void Vector<T>::swap(Vector<T>& other) noexcept
    {
        std::swap(*this, other);
    }
 
    template<typename T>
    inline auto Vector<T>::calc_new_capacity() -> size_type
    {
        return m_capacity == 0 ? 1 : m_capacity * 2;
    }
 
    template<typename T>
    auto Vector<T>::insert_make_space_for_new_elems(const_iterator pos, size_type count) -> iterator
    {
        iterator new_pos{};
 
        if (size() + count > capacity())
        {
            // allocate memory to store new content
            const size_type new_capacity = m_capacity + count;
            pointer new_data = allocator_type().allocate(new_capacity);
 
            // use iterator to move all objects from original vector to new allocated memory
            iterator iter{ begin() };
            iterator new_iter = new_data;
 
            // move all objects before pos from original memory
            while (iter != pos)
            {
                std::allocator_traits<allocator_type>::construct(m_allocator, new_iter, std::move(*iter));
                ++iter;
                ++new_iter;
            }
 
            // make space for new elements
            new_pos = new_iter;
            for (size_t i = 0; i < count; i++)
            {
                ++new_iter;
            }
 
            // move all remaining objects from original memory
            while (iter != end())
            {
                std::allocator_traits<allocator_type>::construct(m_allocator, new_iter, std::move(*iter));
                ++iter;
                ++new_iter;
            }
 
            clear_allocation();
            m_data = new_data;
            m_capacity = new_capacity;
            m_size += count;
        }
        else
        {
            // store address to insert new elements
            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
            iterator iter{ const_cast<iterator>(pos) };
            new_pos = iter;
 
            // move object to the right
            std::move(iter, end(), iter + count);
 
            m_size += count;
        }
 
        return new_pos;
    }
 
    template<typename T>
    void Vector<T>::reallocate(size_type new_cap)
    {
        /*
        * strong exception guarantee by:
        * - throwing exception in case container is too large
        * - using std::move_if_noexcept during reallocation
        */
 
        if (new_cap > max_size())
        {
            throw std::length_error("Pos argument outside of container range");
        }
 
        pointer new_data = allocator_type().allocate(new_cap);
        for (size_t i = 0; i < m_size; i++)
        {
            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
            std::allocator_traits<allocator_type>::construct(m_allocator, new_data + i, std::move_if_noexcept(m_data[i]));
        }
        clear_allocation();
        m_data = new_data;
        m_capacity = new_cap;
        // m_size stay the same as before reallocation
    }
 
    template<typename T>
    void Vector<T>::destroy_elements()
    {
        iterator iter{ begin() };
        while (iter != end())
        {
            std::allocator_traits<allocator_type>::destroy(m_allocator, iter);
            ++iter;
        }
    }
 
    template<typename T>
    void Vector<T>::clear_allocation()
    {
        if (m_data)
        {
            destroy_elements();
            std::allocator_traits<allocator_type>::deallocate(m_allocator, m_data, m_capacity);
            m_capacity = 0;
        }
    }

    template<typename T>
    void swap(Vector<T>& vector1, Vector<T>& vector2) noexcept
    {
        vector1.swap(vector2);
    }

    template<typename T>
    auto operator<<(std::ostream& out, const Vector<T>& vector) -> std::ostream&
    {
        for (size_t i = 0; i < vector.size(); i++)
        {
            out << vector[i] << ' ';
        }
 
        return out;
    }

    template<typename T>
    auto operator==(const Vector<T>& vector1, const Vector<T>& vector2) -> bool
    {
        if (vector1.size() != vector2.size())
        {
            return false;
        }
 
        auto vector1_iter = vector1.cbegin();
        auto vector2_iter = vector2.cbegin();
 
        // vectors have equal size, test condition for one vector
        while (vector1_iter != vector1.cend())
        {
            if (*vector1_iter != *vector2_iter)
            {
                return false;
            }
 
            vector1_iter++;
            vector2_iter++;
        }
 
        return true;
    }

    template<typename T>
    constexpr auto operator<=>(const Vector<T>& vector1, const Vector<T>& vector2)
    {
        auto vector1_iter = vector1.cbegin();
        auto vector2_iter = vector2.cbegin();
 
        while (vector1_iter != vector1.cend() && vector2_iter != vector2.cend())
        {
            if (*vector1_iter < *vector2_iter)
            {
                return std::strong_ordering::less;
            }
            if (*vector1_iter > *vector2_iter)
            {
                return std::strong_ordering::greater;
            }
 
            vector1_iter++;
            vector2_iter++;
        }
 
        if (vector1.size() < vector2.size())
        {
            return std::strong_ordering::less;
        }
        if (vector1.size() > vector2.size())
        {
            return std::strong_ordering::greater;
        }
 
        return std::strong_ordering::equivalent;
    }
}
 
#endif // !VECTOR_H