What happens to a reference variable when its reference 'dies'?

Question

Let's say I create a class called MyClass which contains a reference variable m_my_resource. This reference variable is essentially just a named alias associated with some other memory location.

MyClass

class MyClass
{
    public:    
        MyClass(const MyResource& my_resource) :
            m_my_resource(my_resource){}

    private:
        const MyResource& m_my_resource;
}

Now lets say I try to do the following:

main
{
    MyClass my_class(utils::getMyResource());

    //continue doing stuff
}

What exactly happens in this scenario? I have defined MyClass to only have a single constructor which takes in a reference (lvalue reference) to MyResource.

However, within my main function, I construct an instance of MyClass with a temporary object (rvalue). Why is my code able to compile? Doesn't my_class now contain a reference variable that is associated with some temporary memory location? Essentially the variable in which the reference variable was associated with has now 'died', what happens to the reference variable?

Furthermore, is this a case where I would want my class to have a constructor that accepts rvalue references?

Related/dupe: https://stackoverflow.com/questions/14735630/which-standard-wording-tells-us-that-ref-to-const-temporary-lifetime-extension-o Maybe more specific, but dupe of the former: https://stackoverflow.com/questions/30519148/lifetime-of-temporary-passed-through-function-by-reference — Baum mit Augen, Dec 18 '16 at 16:16
Also *"Why is my code able to compile?"* A *lot* of C++ code that is wrong still compiles. Last but not least, one question per question please. — Baum mit Augen, Dec 18 '16 at 16:18
@BaummitAugen The questions you link to are difficult for me to understand. Is it possible for an instance of `MyClass` to take ownership of this temporary object? — Izzo, Dec 18 '16 at 16:30
Not with your current `const&` setup, no. The temporary dies at the end of the constructor expression. — Baum mit Augen, Dec 18 '16 at 16:36

score 2 · Accepted Answer · edited May 23 '17 at 12:30

Why is my code able to compile?

Just because your code compiles, doesn't mean that it will work correctly. Otherwise, every program in the world will be automatically bug-free, by the virtue of it successfully passing the compilation phase, and there wouldn't be any need for anyone to learn how to use a debugger.

Obviously, things don't work this way.

Doesn't my_class now contain a reference variable that is associated with some temporary memory location?

Yes, it does.

Essentially the variable in which the reference variable was associated with has now 'died', what happens to the reference variable?

Nothing happens to your reference variable. It still exists. But referencing the object -- by that it means attempting to invoke its methods or access its members -- results in undefined behavior.

score 0 · Answer 2 · answered Dec 18 '16 at 16:40

If getMyResource() returns a MyResource object, somewhere in getMyresource() you are allocating memory for the object (on the heap may be), so you have to release the allocated memory. For instance call the MyResource destructor for m_my_resource in the MyClass destructor. If you don't you are going to have memory leaks on your program. In C++ there is no garbage collector to release automatically allocated memory, you have to do it by yourself, but there is non apparent problem compiling, just executing, if memory leaks are a matter.

What happens to a reference variable when its reference 'dies'?

2 Answers2