Re: Default param, is this legal

From:

"Leigh Johnston" <leigh@i42.co.uk>

Newsgroups:

comp.lang.c++

Date:

Wed, 14 Jul 2010 17:50:09 +0100

Message-ID:

<0a6dnb-eQOlYd6DRnZ2dnUVZ7qydnZ2d@giganews.com>

"Leigh Johnston" <leigh@i42.co.uk> wrote in message
news:vOednWi8o-YzeqDRnZ2dnUVZ8oednZ2d@giganews.com...

"Vladimir Jovic" <vladaspams@gmail.com> wrote in message
news:i1kod4$gge$1@news.albasani.net...

Leigh Johnston wrote:

"Leigh Johnston" <leigh@i42.co.uk> wrote in message
news:sJednWpZxaimQqDRnZ2dnUVZ8tidnZ2d@giganews.com...

"Leigh Johnston" <leigh@i42.co.uk> wrote in message
news:6t-dnajvAIeeQKDRnZ2dnUVZ8rCdnZ2d@giganews.com...

"Jonathan Lee" <jonathan.lee.975@gmail.com> wrote in message
news:5b002f84-57dd-4c83-abbd-213b37f27251@s9g2000yqd.googlegroups.com...

On Jul 14, 9:36 am, "Francesco S. Carta" <entul...@gmail.com> wrote:

According to what I see above, the object gets destroyed right after
the
end of the call to that static function, so I think you're NOT safe
using that reference afterwards.

I repeat, that's just an empirical test, I have no idea about what
the
standard mandates about it, although I feel it's UB at least.

Mehhh... [class.temporary] says the temp should exist until the end
of
the full expression. So you might be able to do something like

MyClass b = GetMyClass(MyClass());

and effectively assign to b from the temporary. But it's not at all
clear to me what a full-expression is. I mean, it's defined in
[intro.execution] but then it lists some exceptions to the rule,
which seem to muddy the issue for me.

It is obvious to me at least that the innards of GetMyClass is not
part of the expression used to invoke GetMyClass. Using a dangling
reference is UB and the reference *is* dangling as far as I am
concerned.

/Leigh

Hmmm, maybe I am mistaken, both VC++ and g++ seem to have the temp's
lifetime extend beyond the construction of the copy target.

/Leigh

Obviously I am talking about the following case:

struct MyClass
{
    MyClass() { std::cout << "ctor\n"; }
    MyClass(const MyClass&) { std::cout << "cctor\n"; }
    ~MyClass() { std::cout << "dtor\n"; }
};

const MyClass& GetMyClass(const MyClass& t = MyClass()) { return t; }

int main()
{
    MyClass b = GetMyClass();
}

which outputs:

ctor
cctor
dtor
dtor

I modified your example a bit :

#include <iostream>
struct MyClass
{
    MyClass() { std::cout << "ctor\n"; }
    MyClass(const MyClass&) { std::cout << "cctor\n"; }
    ~MyClass() { std::cout << "dtor\n"; }

    void foo()const{ std::cout << "foo\n"; }
};
const MyClass& GetMyClass(const MyClass& t = MyClass())
{
    std::cout << "GetMyClass\n";
    t.foo();
    return t;
}
int main()
{
    const MyClass &b( GetMyClass() );
    b.foo();
}

This outputs :

ctor
GetMyClass
foo
dtor
foo
Eeek!

Yes I think we all know that that is UB but that is not what I am talking
about; I am talking about how the lifetime of default arguments is defined
wrt the call-site expression. Your example is what happens after the
call-site expression has finished and the reference is obviously dangling
for that case (i.e. the rule for const references and temporary lifetime
does not apply as the function returns a reference not a temporary value).

/Leigh

The following standard text seems to answer my question:

1.9/11: Note: the evaluation of a full-expression can include the evaluation
of subexpressions that are not lexically part of the full-expression. For
example, subexpressions involved in evaluating default argument expressions
(8.3.6) are considered to be created in the expression that calls the
function, not the expression that defines the default argument. -end note ]

/Leigh