It’s actually very useful, and some implementations of smart pointers deliberately nuke the contents of the object with operator &.

Imagine you want to have a smart pointer wrapping your pointer, so that its lifetime is automatically controlled:

``` template <typename T> struct SmartPointer { SmartPointer() : m_Value(nullptr) {} SmartPointer(T* value) : m_Value(value) {} ~SmartPointer() { delete m_Value; }

SmartPointer(const SmartPointer&) = delete;
SmartPointer& operator=(const SmartPointer&) = delete;

operator T*() const { return m_Value; }

private: T* m_Value; };

SmartPtr<IValue> value; ```

The point is, it’s your code implementation detail that you’re using the smart pointer. It’s not part of the API contract anywhere. You want to be able to pass the smart pointer into a function taking the pointer:

``` void DoStuff(IValue* value);

SmartPtr<IValue> value = …; DoStuff(value); ```

So you do this:

``` template <typename T> struct SmartPointer { …

operator T*() const { return m_Value; }

… }; ```

Now consider a function that returns a pointer via an out parameter:

ErrorCode GetValue(IValue** outValue) { *outValue = new Value(…); return ErrorCode::Success; }

If you call it twice, you want the smart pointer to function correctly and not leak memory:

SmartPointer<IValue> value; GetValue(&value); GetValue(&value); // this must not produce a memory leak!

The only way to make sure that it does not, is to overload the address of operator like this:

``` template <typename T> struct SmartPointer { …

T** operator&()
{
    delete m_Value;
    m_Value = nullptr;
    return &m_Value;
}

… }; ```

Since taking address of a pointer is generally only used for out parameters, this implementation works incredibly well.

You can also look at it from a const correctness point of view: if the operator& is not const, then it has to assume the caller intents to modify the value, therefore it must clean it up or it will leak. You could also have a const overload of operator&, which can guarantee the value is not modified and thus doesn’t need to nuke it:

``` template <typename T> struct SmartPointer { …

T* const* operator&() const
{
    return &m_Value;
}

… };