从函数返回对指针的引用与返回指针相同？

Question

I have a feeling that the two examples in the following are equivalent, that is, returning a reference to a pointer and returning a pointer are the same thing. It sounds strange to say this, that a reference to pointer and pointer are the same thing, but I think it is the case in this example:

#include <unordered_map>

struct Animal{};

std::unordered_map<std::string, Animal*> map;

Animal* createNewMapEntry()
{
    return map["new entry"] = new Animal; // map subscript operator will return a reference to the mapped type
                                        // in this case the mapped type is a pointer to Animal
    // Is this the equivalent of doing:
    auto p = new Animal;
    map["new entry"] = p;
    return p;
    // In this case I am returning a pointer to Animal, not a reference to the pointer to animal.
    // That's why I was afraid that in the first example, which returns a "reference" to the Animal pointer
    // that it was returning the "address" of the pointer instead of the pointer, equivalent to returning 
    // a pointer to pointer, which is just like the address to a pointer.
}

If this is true, I think this is a really confusing part of the language, at least for me.

Answer 1

I have a feeling that the two examples in the following are equivalent.

No , they are not.

The first inserts to the map, with key "new entry" and value an Animal object.

The second one doesn't do this, since it just returns the pointer.

---

As MM said: "If a function returns by value and you return an lvalue, the lvalue is converted to prvalue , so the return statement just returns the pointer".

Answer 2

The contents of the compound statement that is the function body have no effect on the return type of the function (unless the return type is auto ).

The return type is Animal* , which is not a reference type. The examples are semantically equivalent.

Answer 3

Conversion of T& to T in expressions is a fundamental aspect of C++. It's one of the first things that happens during expression evaluation. See [expr]/5 :

If an expression initially has the type “reference to T ” ([dcl.ref], [dcl.init.ref]), the type is adjusted to T prior to any further analysis. The expression designates the object or function denoted by the reference, and the expression is an lvalue or an xvalue, depending on the expression.

Since the result of map["new entry"] is Animal*& (and the assignment expression returns an lvalue referring to the left operand ), the & in the return expression disappears, leaving an lvalue Animal* . After that, since the expected return type of createNewMapEntry() is Animal* , an lvalue-to-rvalue conversion takes place and a copy of the pointer is returned.

Note - the return type is always Animal* as declared, you never " return a reference " in this example. In both cases a pointer is returned.