Is std::launder needed in this scenario?

Checkout this SO question. I think answers there are explaining std::launder pretty well.

You might also want to have a look at std::startliftimeas

Bit of an XY answer but I would only use std::launder / startlifetimeas if I needed to put different kinds of data in the same array. If the data is always of a known type, you can use an anonymous union. This allows you to manually manage the lifetime using placement new + destructor call, and you don't need to deal with laundering. In my experience this is easier to reason about.

The basic implementation is this:

template 
union alignas(Alignment) storage {
  T value;
  operator T&() & { return value; }
  operator const T&() const& { return value; }
  operator T&&() && { return staticcast(value); }
  // Don't construct the contained object; the pool will do it.
  storage() {}
   // Don't destroy the contained object; the pool will do it.
  ~storage() {}
  storage(const storage&) = delete;
  storage& operator=(const storage&) = delete;
  storage(storage&&) = delete;
  storage& operator=(storage&&) = delete;
};

1. poolopt - the example shown above

2. tinyopt used by tinyvec - container only uses placement new, but doesn't manually destroy elements. Instead it uses regular delete[] on the array, so this storage has a real destructor.

3. channel_storage - includes move operations, and debug tracking of the lifetime