std::vector<MyItem> v;

v.reserve(50);                     // резервируем память под 50 элементов, без создания самих самих элементов.
assert(v.size() == 0);

v.emplace_back(arg1, arg2, arg3);  // конструируем элементы прямо по месту выделенной памяти, без промежуточных копирований и перемещений
v.emplace_back(arg1, arg2, arg3);  // фактически внутри вектора используется placement new, только скрыто от программиста
v.emplace_back(arg1, arg2, arg3);

assert(v.size() == 3);

union TrulyUnion {
  std::monostate dummy = {};
  T data;
  .....
};

union U {
  .....
  T t;
  .....
};

U* arr = new U[50];

std::construct_at(&arr[0].t);
arr[0].t.foo();

struct U {
  std::aligned_storage_t<sizeof(T), alignof(T)> buf;
  constexpr T& t() { return (T&)buf; }
  constexpr const T& t() const { return (const T&)buf; }

  // и даже перетащить сюда нужное из исходного типа
  auto foo() { return t().foo(); }
};

К>union TrulyUnion {
К>  std::monostate dummy = {};
К>  T data;
К>  .....
К>};
К>

union TrulyUnion {
  std::monostate dummy;
  T data;

  TrulyUnion() : dummy{} {}
  ~TrulyUnion() {}
};

R>std::vector<MyItem> v;

R>v.reserve(50);                     // резервируем память под 50 элементов, без создания самих самих элементов.
R>assert(v.size() == 0);

R>v.emplace_back(arg1, arg2, arg3);  // конструируем элементы прямо по месту выделенной памяти, без промежуточных копирований и перемещений
R>v.emplace_back(arg1, arg2, arg3);  // фактически внутри вектора используется placement new, только скрыто от программиста
R>v.emplace_back(arg1, arg2, arg3);

R>assert(v.size() == 3);
R>

using t_index = std::ptrdiff_t;

    template <typename T>
    struct vector {
        using element_type = T;
        using pointer = element_type *;

        static constexpr std::align_val_t
            s_align{alignof(element_type)};
        static constexpr t_size
            s_size{sizeof(element_type)};

        struct mem {
            static pointer allocate(t_index p_reserve) {
                return reinterpret_cast<pointer>(
                    ::operator new(s_size * p_reserve, s_align, std::nothrow)
                );
            }

            static void free(pointer p_handle) {
                ::operator delete(p_handle, s_align);
            }

            using tfn_allocate = decltype(&allocate);
            using tfn_free = decltype(&free);

            // data
            tfn_allocate
                m_alloc = &allocate;
            tfn_free
                m_free = &free;

            pointer do_alloc(t_index p_reserve) const {
                pointer ret = m_alloc(p_reserve);
                if( ret == nullptr ) { throw std::bad_alloc{}; }
                return ret;
            }
        };

        static constexpr mem s_mem{};

        using mem_const_pointer = const mem *;

    private:

        struct t_data {
            pointer
                m_handle;
            t_index
                m_reserve,
                m_count = 0;
            mem_const_pointer
                m_mem = &s_mem;
        };

        // data
        t_data
            m_data;

    public:

        vector() = delete;
        vector(const vector &) = delete;
        vector(vector &&) = delete;
        vector & operator = (const vector &) = delete;

        vector & operator = (vector && p_other) {
            std::ranges::swap(m_data, p_other.m_data);
        }

        vector(t_index p_reserve) {
            m_data.m_handle = m_data.m_mem->do_alloc(p_reserve);
            m_data.m_reserve = p_reserve;
        }

        ~vector() {
            m_data.m_mem->m_free(m_data.m_handle);
        }
    };

• добавлять в конец или редко на предпоследнюю позицию.
  
• удалять последние N элементов.
  
• иметь быстрый доступ к последним 3-м элементам.

return reinterpret_cast<pointer>(
  ::operator new(s_size * p_reserve, s_align, std::nothrow)
);