overloading the operator ->

Question

I was looking at overloading the -> operator. I came up with the following simple example:

struct foo
{
    int p = 12;
};

struct A
{    
    foo* f;
    A()
    {
        this->f = new foo();
    }
    foo* operator-> ()
    {
        return f;
    }
};

int main()
{
    A a;
    std::cout << a->p; //output 12
}

Although this example works, yet I am hoping if someone could tell me why it works. I was thinking that it should work like this

std::cout << a->->p; //The first arrow returns the pointer 
                     //the second arrow dereferences it

but here it seems like a single arrow not only returns the pointer but it also dereferences it. Is this a special case in C++?

Answer 1

Yes, this is by-design, operator-> will be called recursively on the return value; then we can use such class (so-called smart pointers) in the same way as raw pointers.

If a user-defined operator-> is provided, the operator-> is called again on the value that it returns, recursively, until an operator-> is reached that returns a plain pointer. After that, built-in semantics are applied to that pointer.