Reference to type-erased void* - c++

Question

I'm implementing an iterator adaptor that allows to deal with an old data type saving void*, and I would like to get a forward_iterator that allows to swap values of that old data type, by giving the user a view of the real pointer that is saved in that structure. Example:
auto it = iterator_adaptor<T*>(pos);
where pos->object is a void* that was originally of type T*. The thing is about the reference type:
// within iterator_adaptor
typedef T*& reference;
// I want to promise that to the user.
typedef std::forward_iterator_tag iterator_category;
reference operator*() const { return static_cast<reference>(_pos->object); }
Which yields a compiler error since I cannot wrap a reference over an object of a distinct type. I could cast between references, or between pointers, if types are related, but how could I cast a void* lvalue to a T*& in a non-undefined behaviour way, knowing that _pos->object points to an object of type T?
The only thing that I can think of that might be swallow by the compiler is:
return *reinterpret_cast<T**>(&_pos->object);
or something in this direction, but that must be defined as undefined behaviour by the standard with 100% probability.
NOTE: I would like to return a T*&, not a T&, since some semantics of each T are defined by its address (specifically, there's hash tables that maps T::id() to its address, since each T::id() is unique per T*). If I return T& and the user swaps them, address and id doesn't match anymore, to give some example that might broke the application. I want rather to allow the user to swap the positions of each T* within the structure (because the user saves pointers after all; each T is created dynamically before inserting into the structure), to personalize its ordering for example, or use any std algorithm requiring both, forward and input iterators.
Actually, the "swap" positions thing is not so important, but using the <algorithm> library for algorithms requiring forward iterators is a feature I would like to offer.

Answer 1

Ok, let me get this straight (a mcve would have helped so much):
You have this situation:
X x1{}, x2;
X* p = &x1;
void* vp = reinterpret_cast<void*>(p);
// p is lost
// here you want to recover p such that:
X*& q = /* something magic from vp */;
q = &x2; // this will modify p
If this is the case that is simply impossible because you lost the object p forever. You saved in vp to what p pointed, a.k.a you saved its value, aka you saved the address of x1 (in a type erased way) and that is recoverable, the pointee is recoverable (if you know the original type), but p is lost, it was never saved.
If you want to recover p then you need to save it's address:
X x1{11}, x2{27};
X* p = &x1;
void* vpp = reinterpret_cast<void*>(&p);
// p must not end lifetime !! very important
X*& q = *reinterpret_cast<X**>(vpp);
q = &x2; // will indeed modify p (p must still be alive)
Otherwise you can do this, it's perfectly valid:
T& a = *reinterpret_cast<T*>(pos->object);
T* p = reinterpret_cast<T*>(pos->object);
And finally some standard dessert (emphasis mine):
§8.5.1.10 Reinterpret cast [expr.reinterpret.cast]
An object pointer can be explicitly converted to an object pointer of a different type. 73 When a prvalue v of object pointer
type is converted to the object pointer type “pointer to cv T”, the
result is static_cast<cv T*>(static_cast<cv void*>(v)). [ Note:
Converting a prvalue of type “pointer to T1” to the type “pointer to
T2” (where T1 and T2 are object types and where the alignment
requirements of T2 are no stricter than those of T1) and back to its
original type yields the original pointer value. — end note ]
In the simplest example:
X* p = /* ... */;
void* v = reinterpret_cast<void*>(p);
X* q = reinterpret_cast<X*>(v);
// q is guaranteed to have the original value of p,
// i.e. p == q is true