reinterpret_cast<int&<( int* ) -- Odd behavior

The fallowing code produces output I would not expect:

#include <iostream>
using namespace std;

int main()
{
     int x = 5;
     int* y = &x;
     int& z = reinterpret_cast<int&>( y );

     cout << hex;
     cout << &y << " 0x" << z << '\n';
}

When compiled with g++, the output shows that &y and z are the same.
What I might expect is z to be 5. This is not totally off-putting
since it does exactly what it says, reinterprets the int* to an int&,
but I can't see how this is a good thing. g++ even emits a warning
about it: warning: casting ?int*? to ?int&? does not dereference
pointer. Well, yes, that is exactly the problem.

The real-world code that actually gave me a problem was trying to use C
++ and POSIX threads. I had a buffer type that I passed in as the
argument to my threadable function but I wanted to use it like a
reference. I quickly popped out this:

template< typename T >
void* f( void* _buf )
{
     Buf<T>& buf = reinterpret_cast<Buf<T>&>( _buf );
     ....
}

The error was not obvious for several reasons: I expected it to
somehow reference the buffer and it did not do as expected, there were
many other parts of the function that could have easily caused the
problem (segment fault), g++ did not emit a warning. Actually, on that
last one, g++ ONLY did emit a warning for int, not even unsigned int.

Obviously, since g++ did note the problem, I know there has been much
discussion on this problem and if it were considered a problem in the
language, there'd already be a proposal for it. So, a better question
is what is a good work-a-round that's not completely unintuitive and
won't require a huge comment? What is a good justification for this
behavior? Is it a bug or problem in g++ that it does not warn against
this behavior except in the case of int* to int&?

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]