Why isn't the lifetime of the temporary extended in this case?

Discussion in 'C++' started by Juha Nieminen, Aug 21, 2008.

  1. Let's assume we have a class like this:

    //---------------------------------------------------------
    #include <iostream>

    class MyClass
    {
    public:
    MyClass() { std::cout << "constructor\n"; }
    ~MyClass() { std::cout << "destructor\n"; }

    const MyClass& print(int i) const
    {
    std::cout << i << std::endl;
    return *this;
    }
    };
    //---------------------------------------------------------

    Now, if I create a reference to a temporary instance of this class,
    the lifetime of that instance will be extended for the lifetime of the
    reference. For example:

    //---------------------------------------------------------
    int main()
    {
    std::cout << "Before\n";
    const MyClass& obj = MyClass(); //*
    std::cout << "After\n";
    obj.print(2);
    }
    //---------------------------------------------------------

    This program will print:

    Before
    constructor
    After
    2
    destructor

    This is even so if the temporary is the return value of a function.
    For example, let's assume we have the function:

    MyClass getMyClass() { return MyClass(); }

    Now if we change the line marked with //* to this:

    const MyClass& obj = getMyClass(); //*

    the result will still be the same. So clearly the lifetime of the return
    value of a function is extended by the reference.

    Now comes the puzzling part, and my actual question. Suppose that we
    change the line marked with //* to this:

    const MyClass& obj = MyClass().print(1); //*

    Suddenly the output changes:

    Before
    constructor
    1
    destructor
    After
    2

    Now the temporary object is destroyed after the reference assignment
    ends! The second print() call is now calling a destroyed object! (Oddly
    gcc doesn't issue even a warning about this.)

    The same is true for:

    const MyClass& obj = getMyClass().print(1); //*

    But why? Why does the print() function returning a reference to itself
    change the semantics of the lifetime of the temporary object? Why isn't
    the reference extending the lifetime of the object anymore? Why does the
    reference extend the lifetime of the return value of getMyClass(), but
    not the lifetime of the return value of MyClass::print()? How does it
    make even sense that a reference can be created to an object which is
    destroyed immediately after the reference is created?
     
    Juha Nieminen, Aug 21, 2008
    #1
    1. Advertisements

  2. But I thought the whole idea of references is that they would be safer
    than pointers.
     
    Juha Nieminen, Aug 22, 2008
    #2
    1. Advertisements

  3. Juha Nieminen

    anon Guest

    class MyClass
    I didn't quite understand this. Do you say that the call:
    obj.Print(2);
    is an undefined behavior?

    Would this:
    MyClass const& bad = pass(pass(pass(pass(MyClass()).print(3))));
    be UB as well?
     
    anon, Aug 22, 2008
    #3
    1. Advertisements

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments (here). After that, you can post your question and our members will help you out.