static_allocator to make static_vector from std::vector - c++

Question

I want to implement static_vector, i.e. container like std::vector, but having fixed size storage statically allocated (reserved) on construction and never exceeded during its lifetime.
Because allocator object is a data member of almost every (except std::array) container in C++ standard library, I decided to make raw storage a part of allocator. In the case std::vector virtually will contain whole storage it use.
#include <type_traits>
#include <new>
#include <cassert>
template<size_t N>
struct make
{
template<typename T>
struct static_allocator
{
using value_type = T;
using propagate_on_container_copy_assignment = std::false_type;
using propagate_on_container_move_assignment = std::false_type;
using propagate_on_container_swap = std::false_type;
[[nodiscard]] T * allocate(std::size_t n)
{
if (n != N)
throw std::bad_alloc();
return reinterpret_cast<T*>(&m_storage);
}
void deallocate(T * p, std::size_t n) noexcept
{
assert(p == reinterpret_cast<T*>(&m_storage));
assert(n == N);
}
private:
std::aligned_storage_t<sizeof(T) * N, alignof(T)> m_storage;
};
};
template<size_t N, typename T>
bool operator == (const typename make<N>::template static_allocator<T> & lhs, const typename make<N>::template static_allocator<T> & rhs) { return &lhs == &rhs; }
template<size_t N, typename T>
bool operator != (const typename make<N>::template static_allocator<T> & lhs, const typename make<N>::template static_allocator<T> & rhs) { return !(lhs == rhs); }
#include <vector>
#include <utility>
#include <iterator>
#include <algorithm>
#include <iostream>
int main()
{
std::vector<int, make<10>::static_allocator<int>> v;
v.reserve(10);
for (int i = 0; i < 10; ++i) {
v.push_back(i);
}
auto u = std::move(v);
std::copy(std::cbegin(u), std::cend(u), std::ostream_iterator<int>(std::cout, " "));
std::cout << std::endl;
}
On destruction the code gives an error:
prog.exe: prog.cc:29: void make<10>::static_allocator<int>::deallocate(T *, std::size_t) [N = 10, T = int]: Assertion `p == reinterpret_cast<T*>(&m_storage)' failed.
The cause of the error is that during move construction of std::vector underlying allocator is also move constructed. There is postcondition for allocators a and a1 of type A: a == a1 after A a1(std::move(a));, which breaks whole endeavour.
The postcondition makes allocators in Standard Library too restricted, I believe. Is there chance would it be removed in the future? Is there strong theoretical reason to keep this restriction in the Standard?

Answer 1

Here is my implementation of what you possibly try to achieve.
https://github.com/alekstheod/static_vector
Basically store the array -> data inside your own definition of the vector and replace the allocator to use this data when allocating a memory.

Answer 2

Based on your saying:
I want to implement static_vector, i.e. container like std::vector, but having fixed size storage statically allocated (reserved) on construction and never exceeded during its lifetime.
Looks like a static array would be the best, since you dont need to exceed the size ever, just do something like
int arr[your_size];
and intialize what you need to intialize, set all the other values to INT_MAX or INT_MIN.