Cast pointer to reference pointer - c++

Question

In the code below I am casting pointer type to reference pointer type in order to change the pointer to point somewhere else:
inline void SWAP_POINTERS(void*& p1,void*& p2)
{
void* temp = p1;
p1 = p2;
p2 = temp;
}
When I call the function I ge the following error:
note: candidate function not viable: no known conversion from 'int32_t *' (aka 'int *') to 'void *&' for 1st argument
Do I need to cast?
Why do I need to cast since it is void*?
Limitation: no templates.
calling the code like this:
unsigned int* a;
double* b;
SWAP_POINTERS(a,b);

Answer 1

1. You're probably breaking strict aliasing once you dereference one of the pointers after swapping.
unsigned int* a;
double* b;
SWAP_POINTERS(a,b);
Don't swap pointers which do not point to the same type however. (Note that char aliases other types but that is an exception.)
2. You cannot convert int* to void*& implicitly.
int* is implicitly convertible to void* but the conversion creates an rvalue which cannot be bound to an lvalue reference.
In order to use SWAP_POINTERS with the signature shown in the question, one would have to create lvalues of type void* first and pass those to SWAP_POINTERS.
Example:
int a{0}, b{1};
int * pa = &a;
void * vpa = pa;
int * pb = &b;
void * vpb = pb;
SWAP_POINTERS(vpa, vpb); // swaps vpa and vpb - OF COURSE :)
Please note that this doesn't solve the (probably inteded) swapping of (unrelated) pointers with minimal code. Its just an explanation of why the original code with void*& in place did not work when passing int* and how a call to the original function would have to look in order to be able to operate (on its function arguments...).
3. Swap pointers via std::swap
int a{0}, b{1};
int * pa = &a;
int * pb = &b;
std::swap(pa, pb);

Answer 2

This will do what you think you want, but it's totally NOT recommended. Templates (or std::swap) really are the right answer here.
First, define an inline function to take void **
inline void SWAP_POINTERS2(void** p1,void** p2)
{
void* temp = *p1;
*p1 = *p2;
*p2 = temp;
}
Then, define a macro to perform unpleasant casts.
#define SWAP_POINTERS(a,b) SWAP_POINTERS2((void **) &a, (void **) &b)
Or, if you prefer using static_cast:
#define SWAP_POINTERS(a,b) SWAP_POINTERS2(static_cast<void**>(static_cast<void *> (&a)), static_cast<void**>(static_cast<void *>(&b)))
Now this "works" to the extent that it compiles and does what you want. I have no idea how you'd then use the swapped pointers, of course...
unsigned int* a;
double* b;
SWAP_POINTERS(a,b);