Function argument lifespan

[int2str]

All,

As the simple sample program below demonstrates, function arguments are
destroyed after the return value of the function has been evaluated. As
opposed to local function variables, which are destroyed before the
function returns.

Is this correct? (To the best of my knowledge it is)
Where in the standard is this described?

Thanks,
Andre

--- Example ---

#include <iostream>

using namespace std;

class test
{
public:
test( string s = "")
: s_(s)
{
cout << "test::test()\t " << s_ << endl;
}

test( const test &org)
{
cout << "test::test(cop y)" << endl;
s_ = "copy of " + org.s_ ;
}

~test()
{
cout << "test::~test()\ t" << s_ << endl;
}

const string & getStr() const
{
return s_;
};

private:
string s_;
};

const test & f( test arg )
{
test l("local");
return arg;
}

int main()
{
test c("main");
cout << "\n\t\tf() = [" << f( c ).getStr() << "]\n" << endl;
}

[Victor Bazarov]

in*****@gmail.c om wrote:

As the simple sample program below demonstrates, function arguments
are destroyed after the return value of the function has been
evaluated. As opposed to local function variables, which are
destroyed before the function returns.

Is this correct? (To the best of my knowledge it is)
Where in the standard is this described?

3.8 Object lifetime, 12.2 Temporary objects. Probably more...

V

[int2str]

Victor Bazarov wrote:

Where in the standard is this described?

3.8 Object lifetime, 12.2 Temporary objects. Probably more...

V

Victor,

Thank you very much for your quick and knowledgable answer!
Much appreciated!

Thanks,
Andre

[Greg]

in*****@gmail.c om wrote:

All,

As the simple sample program below demonstrates, function arguments are
destroyed after the return value of the function has been evaluated. As
opposed to local function variables, which are destroyed before the
function returns.

Is this correct? (To the best of my knowledge it is)
Where in the standard is this described?

Thanks,
Andre

--- Example ---

#include <iostream>

using namespace std;

class test
{
public:
test( string s = "")
: s_(s)
{
cout << "test::test()\t " << s_ << endl;
}

test( const test &org)
{
cout << "test::test(cop y)" << endl;
s_ = "copy of " + org.s_ ;
}

~test()
{
cout << "test::~test()\ t" << s_ << endl;
}

const string & getStr() const
{
return s_;
};

private:
string s_;
};

const test & f( test arg )
{
test l("local");
return arg;
}
The f() routine returns a reference to a function parameter whose
lifetime ends at function exit. Therefore I believe that the behavior
of your program is undefined.
int main()
{
test c("main");
cout << "\n\t\tf() = [" << f( c ).getStr() << "]\n" << endl;
}

I don't believe it's possible to draw any sound conclusions from
running this program due to the implementation of f() above.

Greg

[aling]

This is nonsense sample, cause f() returns a reference to a temporary
object which is copy of "test arg".

[int2str]

Greg wrote:

const test & f( test arg )
{
test l("local");
return arg;
}

The f() routine returns a reference to a function parameter whose
lifetime ends at function exit. Therefore I believe that the behavior
of your program is undefined.

Actually, I do think the behaviour is defined. My original question was
how to better define why it is legal - i.e. where it is mentionend in
the standard.

Victor pointed me to item 12.2 in the C++ Standard. I believe
paragraphs 2 and onward explain it (too long to reproduce here).

Given the example code (para. 2):
X f(X); // X is a class
...
X a(1);
a=f(a);

The standard writes:
"...the expression a=f(a) requires a temporary for either the
argument 'a' or the result of f(a) to avoid undesired aliasing of 'a'."

B.Stroustrup writes (similar wording to the standard para. 3) in "The
C++ Programming Language", section 10.4.10:
"Unless bound to a reference or used to initialize a named object, a
temporary object is destroyed at the end of the full expression in
which it was created."

IMHO the temporary object (arg) is created as part of the cout <<
f(c)... expression. Thus it exists until the end of that whole
expression (once again IMHO).

Is this not correct?

Cheers,
Andre

[int2str]

aling wrote:

This is nonsense sample,
What part is nonsense?
What is your definition of nonsene in this context?
cause f() returns a reference to a temporary object
That part I agree with...
which is copy of "test arg".

....this part I don't.

A reference to "arg" is returned, which is a copy of "c".
"arg" was created as part of the f(c) expression (IMHO).

Cheers,
Andre

[Karl Heinz Buchegger]

"in*****@gmail. com" wrote:

IMHO the temporary object (arg) is created as part of the cout <<
f(c)... expression. Thus it exists until the end of that whole
expression (once again IMHO).

Actually I think you are right. *In this case* the whole thing
is defined.
Nevertheless IMHO it is poor programming praxis, if the validity
of a function depends on the exact details that function is used.

--
Karl Heinz Buchegger
kb******@gascad .at

[Greg]

in*****@gmail.c om wrote:

Greg wrote:

const test & f( test arg )
{
test l("local");
return arg;
}

The f() routine returns a reference to a function parameter whose
lifetime ends at function exit. Therefore I believe that the behavior
of your program is undefined.

Actually, I do think the behaviour is defined. My original question was
how to better define why it is legal - i.e. where it is mentionend in
the standard.

Victor pointed me to item 12.2 in the C++ Standard. I believe
paragraphs 2 and onward explain it (too long to reproduce here).

Given the example code (para. 2):
X f(X); // X is a class
...
X a(1);
a=f(a);

The standard writes:
"...the expression a=f(a) requires a temporary for either the
argument 'a' or the result of f(a) to avoid undesired aliasing of 'a'."

B.Stroustrup writes (similar wording to the standard para. 3) in "The
C++ Programming Language", section 10.4.10:
"Unless bound to a reference or used to initialize a named object, a
temporary object is destroyed at the end of the full expression in
which it was created."

IMHO the temporary object (arg) is created as part of the cout <<
f(c)... expression. Thus it exists until the end of that whole
expression (once again IMHO).

Is this not correct?

Cheers,
Andre

You are correct abut the temporary. But the program's behavior is still
undefined.

The problem is not the lifetime of the temporary reference that the
function returns, but the lifetime of the object that it is bound to.
It is bound to a function parameter passed by value - not by reference.
Because it is a value parameter, its lifetime is certain to end before
the function exits. So the return value used in the calling routine is
in fact in scope, but the variable it is bound to has been destroyed.
Accessing a reference to a deallocated variable is undefined behavior.

Greg

[int2str]

Greg wrote:

in*****@gmail.c om wrote:

Greg wrote:

.... The problem is not the lifetime of the temporary reference that the
function returns, but the lifetime of the object that it is bound to.
It is bound to a function parameter passed by value - not by reference.
Because it is a value parameter, its lifetime is certain to end before
the function exits. So the return value used in the calling routine is
in fact in scope, but the variable it is bound to has been destroyed.
Accessing a reference to a deallocated variable is undefined behavior.

I think that the bottom line of our disagreement is the question
whether a pass-by-value function argument has function scope or not. I
do not believe it does.

The function argument - especially in the case of a complex class - is
allocated (and copy constructed) BEFORE the function is entered. Thus
its lifetime is not within the function scope but bound by the complete
expression it is part of. As such, as outlined by the previous
quotations, I believe it is not destroyed before the full expression is
evaluated.

This case only really matter of course if you return a reference to the
argument like I did. But it can be illustrated similarly even with a
function that doesn't return the argument in any form:

int f1( my_class arg )
{
return 42;
}

When calling this function, a temporary my_class object is allocated
and copy constructed, and not destroyed until the full expression it
may be part of is evaluate.

E.x:
cout << f1( c ) << " is the answer." << endl;

That is how I understand and interpret the standard - I may be wrong.

Cheers,
Andre