returning a string from an ostringstream

[Thomas Lenz]

Please consider the following code snippet:

string myfunction()
{ ostringstream oss;
oss << "junk";
// do something more with oss; I can't make it const...
return oss.str();
}

Is the returned string object still valid after myfunction() has returned? I
wonder because oss should be destroyed at the bottom '}', shouldn't it? So
what about its string? (The above code seems to work on my machine, but is
it guaranteed to work?)

Or is it safer to explicitly construct the string to return as a temporary
object, like

return string(oss.str());

?

Thanks in advance for any comments,

Thomas

 

[Guest]

Please consider the following code snippet:

string myfunction()
{ ostringstream oss;
oss << "junk";
// do something more with oss; I can't make it const...
return oss.str();
}

Is the returned string object still valid after myfunction() has returned? I
wonder because oss should be destroyed at the bottom '}', shouldn't it? So
what about its string? (The above code seems to work on my machine, but is
it guaranteed to work?)

It is safe because myfunction() returns a string (and not a reference or
pointer to string) so the value returned from oss.str() will be copied
when myfunction() returns.

 

[Jim Langston]

Please consider the following code snippet:

string myfunction()
{ ostringstream oss;
oss << "junk";
// do something more with oss; I can't make it const...
return oss.str();
}

Is the returned string object still valid after myfunction() has returned?
I
wonder because oss should be destroyed at the bottom '}', shouldn't it? So
what about its string? (The above code seems to work on my machine, but is
it guaranteed to work?)

Or is it safer to explicitly construct the string to return as a temporary
object, like

return string(oss.str());

?

As Victor says, you are returning by copy. You are returning a std::string,
so oss.str() is copied into a temporary, which is returned.

It would be a problem, however, if you returned a reference or a pointer.

std::string& myfunction()
{ ostringstream oss;
oss << "junk";
// do something more with oss; I can't make it const...
return oss.str();
}

Now you would have a problem, because you are returning a reference (a type
of pointer) to something that is destroyed when the function ends.

 

[Thomas Lenz]

am Dienstag 23 Oktober 2007 11:05 schrieb Jim Langston:

As Victor says, you are returning by copy. You are returning a
std::string, so oss.str() is copied into a temporary, which is returned.

It would be a problem, however, if you returned a reference or a pointer.

std::string& myfunction()
{ ostringstream oss;
oss << "junk";
// do something more with oss; I can't make it const...
return oss.str();
}

Now you would have a problem, because you are returning a reference (a
type of pointer) to something that is destroyed when the function ends.

thanks everybody.

So there are two string objects involved: one being returned by oss.str(),
and will die when myfunction() returns, and a copied one that lives outside
of myfunction(), right?

What happened if I change the return statement to

return string(oss.str());

? Would this yield 3 string objects? (one coming from oss.str(), one
produced by the string(...) Constructor, and one copied by the return
statement)? (Assuming the compiler doesn't optimize it away)

thanks,
Thomas

 

[Guest]

am Dienstag 23 Oktober 2007 11:05 schrieb Jim Langston:


thanks everybody.

So there are two string objects involved: one being returned by oss.str(),
and will die when myfunction() returns, and a copied one that lives outside
of myfunction(), right?

What happened if I change the return statement to

return string(oss.str());

? Would this yield 3 string objects? (one coming from oss.str(), one
produced by the string(...) Constructor, and one copied by the return
statement)? (Assuming the compiler doesn't optimize it away)

Yes.

 

[Jim Langston]

am Dienstag 23 Oktober 2007 11:05 schrieb Jim Langston:


thanks everybody.

So there are two string objects involved: one being returned by oss.str(),
and will die when myfunction() returns, and a copied one that lives
outside
of myfunction(), right?

What happened if I change the return statement to

return string(oss.str());

? Would this yield 3 string objects? (one coming from oss.str(), one
produced by the string(...) Constructor, and one copied by the return
statement)? (Assuming the compiler doesn't optimize it away)

Yes, but be careful of "lives outside of myfunction". It only lives as long
as the stament. For instance:

std::string Foo = MyFunction(); // Okay
std::string& Foo = MyFunction(); // Not okay

The string that MyFunction returns is a temporary object. It will only live
as long as the statement that the MyFunction() call is on. So if you
actually want to do something with the string, you got to copy it yet again,
or use it right away (such as an output statement).

std::cout << MyFunction(); // Okay

 

[Rajesh S R]

Yes, but be careful of "lives outside of myfunction". It only lives as long
as the stament. For instance:

std::string Foo = MyFunction(); // Okay
std::string& Foo = MyFunction(); // Not okay

Won't this produce a compilation error?
U are initializing a non-const reference by an rvalue.

 

[Jim Langston]

Won't this produce a compilation error?
U are initializing a non-const reference by an rvalue.

Which?

Attempting to return oss.str(); as a std::string& results in a compile error
(which is one reason it's not okay).
A reference that is not to 'const' cannot be bound to a non-lvalue

Attempting to intilaize a reference to a temporary is also producing a
compile time error. Returning oss.str() as a std::string and
std::string& Foo = MyFunction(); // Not okay
results in
error C2040: 'Foo' : 'std::string &' differs in levels of indirection from
'std::string'
error C2440: 'initializing' : cannot convert from 'std::string' to
'std::string &'

Luckily the compiler is smart enough to keep us from doing most dumb stuff.