std::uninitialized_construct_using_allocator

#include <iostream>
#include <vector>
#include <utility>
#include <memory>
#include <new>

// 状態付きアロケータ
template <typename T>
class MyAlloc {
public:
  using value_type = T;
  T* allocate(std::size_t n) { return static_cast<T*>(::operator new(sizeof(T) * n)); }
  void deallocate(T* p, std::size_t n) { ::operator delete(static_cast<void*>(p), sizeof(T) * n); }
  MyAlloc(int state) noexcept : state(state) {}
  template <typename U>
  MyAlloc(const MyAlloc<U>& o) noexcept : state(o.state) {}
  int state;
};

template <typename T>
bool operator==(const MyAlloc<T>& lhs, const MyAlloc<T>& rhs) noexcept
{
  return lhs.state == rhs.state;
}

template <typename T>
bool operator!=(const MyAlloc<T>& lhs, const MyAlloc<T>& rhs) noexcept
{
  return lhs.state != rhs.state;
}

// 型別名
using VEC = std::vector<int, MyAlloc<int>>;

using V = std::pair<std::pair<VEC, int>, int>;

int main()
{
  alignas(V) char s[sizeof(V)];
  auto p = std::uninitialized_construct_using_allocator(
    reinterpret_cast<V*>(s),
    MyAlloc<int>{42}, std::make_pair(VEC{MyAlloc<int>(99)}, 1), 2
  );
  std::cout << p->first.first.get_allocator().state << '\n';
}