Why GCC 5.3.0 gives warning when binding reference to "this" pointer

Question

Here is the minimal example:

class A
{
    A* const& this_ref;
public:
    A() : this_ref(this) {}
};

GCC 5.3.0 gives warning:

warning: a temporary bound to 'A::this_ref' only persists until the constructor exits [-Wextra] A() : this_ref(this) {}

Is this a temporary then? What the... MSVC 2015 is silent about this, and referring to class members by this_ref->member outside the constructor in my case gives expected behaviour (but might be just a case of UB, not sure).

EDIT:

Note this question extends one linked as possible duplicate, because it's not generic question about way to create such reference, but about warning GCC (and possible other compilers other than MSVC) produces when creating one.

Possible duplicate of [Is it possible to get reference to 'this' pointer in class body without using the class name?](http://stackoverflow.com/questions/39258248/is-it-possible-to-get-reference-to-this-pointer-in-class-body-without-using-th) — skypjack, Sep 12 '16 at 09:21
Since `this` exists only while the constructor is running and then ceases to exist, it is temporary. (Which is exactly what the warning is telling you.) — David Schwartz, Sep 12 '16 at 09:29
Can you take an address of `this`? Don't think so. How do you expect the reference to work if the referent has no address? — n. m. could be an AI, Sep 12 '16 at 09:42
@skypjack I suppose both questions are due to a misunderstanding of the `this` pointer, but the "possible to get a reference..." one makes no sense before reading the comments and very little sense after reading the comments. Also, this question asks about a *specific warning* in a *specific compiler version*, whereas the linked one amounts to "I'm trying to replace a bizarrely Perl-esque renaming macro with C++11 features because reasons." — Kyle Strand, Sep 12 '16 at 17:12
@KyleStrand You should rather read the answers of the linked questions. Anyway, I have not to persuade you about anything. I voted to close as a duplicate, my two cents, it's a right and a duty, so... — skypjack, Sep 12 '16 at 17:42

Kerrek SB · Accepted Answer · 2016-09-12T09:29:21.840

You are creating a dangling reference. Your code is no different from this code:

struct X
{
    const int & r;
    X() : r(5) {}
};     // ^^^^ dangles

There is no "object" called this. this is a keyword, and when used as an expression, it is a prvalue (a temporary) containing the address of the current instance.

Here's another example of the creation of a similarly dangling reference from something that looks like an object but isn't:

struct Y
{
    int a[10];
    int* const & r;

    Y() : r(a) {}
};

Here, a is a named entity (an lvalue), but in the initializer of r, the expression a is a prvalue (namely the result of the decay of the array).

The overall message is that you should be careful with the language feature that allows const lvalue references to bind to rvalues. Its main purpose is to make function calls easy, but its other uses are much hairier.

score 5 · Answer 2 · edited Jun 20 '20 at 09:12

Is this a temporary then?

To be precise, this is not temporary, but a temporary is created here.

Firstly, this is prvalue,

The following expressions are prvalue expressions:

the this pointer;

Secondly, temporary object will be created when binding reference to a prvalue,

Temporary objects are created when a prvalue is materialized so that it can be used as a glvalue, which occurs (since C++17) in the following situations:

binding a reference to a prvalue

That's why GCC gives warning, because this_ref is bound to a temporary created. (And then become dangled later, which leads to UB.)

Why GCC 5.3.0 gives warning when binding reference to "this" pointer

2 Answers2

Linked