Use case of overloading address-of operator

Question

I think it's dangerous to overload the address-of operator &, because it's easy to overlook the use of std::addressof() in implementing templates that actually need it. Still, I'm wondering what would be a proper use case of overloading this operator. Particularly, is there any class (template) in the standard library that has done this? Finally, since std::addressof() is introduced since C++11, is there any way to take the address of an object that has this overloading in C++03?

Answer 1

& is often overloaded when building smart pointer classes, as it makes them easier to use: more often than not you want the bare managed pointer, not the address of the smart pointer object.

Neglecting the evolutionary backwater that was std::auto_ptr, smart pointer classes such as std::unique_ptr and std::shared_ptr have been introduced into the standard since C++11. std::addressof was introduced in that standard since taking the real address of an object is occasionally required.

A possible implementation of std::addressof is trivial but is smelly due to the amount of casting required; a possible implementation is¹

template< class T >
T* addressof(T& arg) 
{
    return reinterpret_cast<T*>(
               &const_cast<char&>(
                  reinterpret_cast<const volatile char&>(arg)));
}

Other more exotic uses of overloading & are for supporting EBNF grammar parsers. Boost Spirit does this with remarkable alacrity.

---

¹ Quoting from http://en.cppreference.com/w/cpp/memory/addressof

Answer 2

No, the only way is the std::addressof() in C++11 or later, or its implementation for earlier versions, see above:

template< class T >
T* addressof(T& arg) 
{
    return reinterpret_cast<T*>(
               &const_cast<char&>(
                  reinterpret_cast<const volatile char&>(arg)));
}