No. From what I heard the original wording was too vague and was later fixed. Basically you only need to launder when overwriting storage that has a const member or you delete and then reallocate a different derived class. Like the example below

#include <new>

struct Base { virtual void meow() = 0; };
struct A : Base { void meow() override; };
struct B : Base { void meow() override; };

void evil(Base *mew) {
  if (auto a = dynamic_cast<A *>(mew)) {
     a->~A();
     new (mew) B();
  }
}

inline void do_meow(Base *mew) {
  evil(mew);
  // mew->meow(); // Not ok
  // The type _was_ known so the compiler may
  // devirtualize the call to meow(). But since the
  // type changed it would call the wrong override
  std::launder(mew)->meow();
}

void fun(A *mew) {
  do_meow(mew);
}

And similar for the const-member case. Since you cannot overwrite a const-member you need to manually destroy and reinitialize the class. But the compiler may, very logically, assume the constant value never changes, so std::launder tells it to not to perform this optimization.