#include <array>
#include <iostream>
#include <memory>

const size_t N = 5;

struct A
{
  int x;
  A(int x) : x(x) { std::cout << "Created" << std::endl; }
  A(const A& rhs) : x(rhs.x) { std::cout << "Copied" << std::endl; }
  ~A() { std::cout << "Destroyed" << std::endl; }
};

int makeElement(size_t i)
{
  return i * i;
}

struct Deleter 
{
  Deleter() {};
  void operator()(std::array<A, N>* p) const 
  { 
    for (auto& item : *p) { item.~A(); }
    std::return_temporary_buffer(p); 
  };
};

std::unique_ptr<std::array<A, N>, Deleter> makeArrayDynamically()
{
  A* buf;
  std::tie(buf, std::ignore) = std::get_temporary_buffer<A>(N);
  for (size_t i = 0; i < N; ++i)
  {
    new (buf + i) A(makeElement(i));  // Yeah, I will have a leak if some constructor throws
  }
  return { reinterpret_cast<std::array<A, N>*>(buf), Deleter() };
}

int main() 
{
  const auto pArr = makeArrayDynamically();

  for (const auto& item : *pArr)
  {
    std::cout << item.x << std::endl;    
  }
}