This is an entirely hypothetical question about shared_ptr aliasing constructor and UB.
Lets imagine a situation where we store std::shared_ptr<void> in some database. Lets also imagine that we can safely cast a void * pointing to an instance of a parent type A to a pointer of a child type B (ex. via a compile-time generated proxy).
Will the following situation result in UB, or is it safe?
std::shared_ptr<void> sp_v = get_vp(); // sp_v points to an instance of parent type `A`
B *ptr_b = cast_to_b(sp_v.get()); // Safe cast of `void *` aliasing `A *` to `B *` via a proxy.
std::shared_ptr<B> sp_b = std::shared_ptr<B>{sp_v, ptr_b}; // <- Potential UB here?
From what i assume, there should be no UB, as aliasing constructor should only share the control block, however i am not sure if there are any implementation-defined edge cases or STL definition quirks here that might result in UB.
From https://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr:
... such as in the typical use cases where ptr is a member of the object managed by r or is an alias (e.g., downcast) of r.get() ...
So this is exactly the envisioned use case.