是否允许重用非静态数据成员的存储，如果是，在什么条件下？

考虑该计划

#include<new>
#include<type_traits>
using T = /*some type*/;
using U = /*some type*/;
static_assert(std::is_object_v<T>);
static_assert(std::is_object_v<U>);
static_assert(sizeof(U) <= sizeof(T));
static_assert(alignof(U) <= alignof(T));
struct A {
T t /*initializer*/;
U* u;
A() {
t.~T();
u = ::new(static_cast<void*>(&t)) U /*initializer*/;
}
~A() {
u->~U();
::new(static_cast<void*>(&t)) T /*initializer*/;
}
A(const A&) = delete;
A(A&&) = delete;
A& operator=(const A&) = delete;
A& operator=(A&&) = delete;
};
int main() {
auto a = new A;
*(a->u) = /*some assignment*/;
delete a; /*optional*/
A b; /*alternative*/
*(b.u) = /*some assignment*/; /*alternative*/
}

除了static_assert之外，对象类型T和U还需要满足哪些条件，以便程序定义了行为(如果有(？

它是否取决于实际调用A的析构函数(例如，是否存在/*optional*/或/*alternative*/行(？

这是否取决于A的存储持续时间，例如是否使用main中的/*alternative*/行？

请注意，程序在放置新之后不使用t成员，除非在析构函数中。当然，不允许在其存储被不同类型的占用时使用它。

另请注意，我不鼓励任何人编写这样的代码。我的目的是更好地理解语言的细节。特别是，我至少没有发现任何禁止这种放置新闻的东西，只要不调用析构函数。

另请参阅我的另一个问题，即修改版本在封闭对象的构建/破坏期间不执行放置新闻，因为根据一些评论，这似乎引起了复杂性。

评论中要求的具体示例展示了我认为代表不同感兴趣情况的类型子集的更广泛问题：

#include<new>
#include<type_traits>
struct non_trivial {
~non_trivial() {};
};
template<typename T, bool>
struct S {
T t{};
S& operator=(const S&) { return *this; }
};
template<bool B>
using Q = S<int, B>; // alternatively S<const int, B> or S<non_trivial, B>
using T = Q<true>;
using U = Q<false>;
static_assert(std::is_object_v<T>);
static_assert(std::is_object_v<U>);
static_assert(sizeof(U) <= sizeof(T));
static_assert(alignof(U) <= alignof(T));
struct A {
T t;
U* u;
A() {
t.~T();
u = ::new(static_cast<void*>(&t)) U;
}
~A() {
u->~U();
::new(static_cast<void*>(&t)) T;
}
A(const A&) = delete;
A(A&&) = delete;
A& operator=(const A&) = delete;
A& operator=(A&&) = delete;
};
int main() {
auto a = new A;
*(a->u) = {};
delete a; /*optional*/
// A b; /*alternative*/
// *(b.u) = {}; /*alternative*/
}