By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
457,916 Members | 1,336 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 457,916 IT Pros & Developers. It's quick & easy.

returning a string from an ostringstream

P: n/a
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

Oct 22 '07 #1
Share this Question
Share on Google+
7 Replies


P: n/a
On 2007-10-22 20:06, Thomas Lenz wrote:
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.

--
Erik Wikström
Oct 22 '07 #2

P: n/a
"Thomas Lenz" <le****@gmx.dewrote in message
news:47***********************@newsspool3.arcor-online.net...
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.
Oct 23 '07 #3

P: n/a
am Dienstag 23 Oktober 2007 11:05 schrieb Jim Langston:
"Thomas Lenz" <le****@gmx.dewrote in message
news:47***********************@newsspool3.arcor-online.net...
>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.
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

Oct 23 '07 #4

P: n/a
On 2007-10-23 13:30, Thomas Lenz wrote:
am Dienstag 23 Oktober 2007 11:05 schrieb Jim Langston:
>"Thomas Lenz" <le****@gmx.dewrote in message
news:47***********************@newsspool3.arcor-online.net...
>>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.

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.

--
Erik Wikström
Oct 23 '07 #5

P: n/a
"Thomas Lenz" <le****@gmx.dewrote in message
news:47***********************@newsspool2.arcor-online.net...
am Dienstag 23 Oktober 2007 11:05 schrieb Jim Langston:
>"Thomas Lenz" <le****@gmx.dewrote in message
news:47***********************@newsspool3.arcor-online.net...
>>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.

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
Oct 23 '07 #6

P: n/a
On Oct 23, 7:00 pm, "Jim Langston" <tazmas...@rocketmail.comwrote:
"Thomas Lenz" <len...@gmx.dewrote in message

news:47***********************@newsspool2.arcor-online.net...
am Dienstag 23 Oktober 2007 11:05 schrieb Jim Langston:
"Thomas Lenz" <len...@gmx.dewrote in message
news:47***********************@newsspool3.arcor-online.net...
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.
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
Won't this produce a compilation error?
U are initializing a non-const reference by an rvalue.

Oct 23 '07 #7

P: n/a
"Rajesh S R" <SR**********@gmail.comwrote in message
news:11**********************@t8g2000prg.googlegro ups.com...
On Oct 23, 7:00 pm, "Jim Langston" <tazmas...@rocketmail.comwrote:
>"Thomas Lenz" <len...@gmx.dewrote in message

news:47***********************@newsspool2.arcor-online.net...
am Dienstag 23 Oktober 2007 11:05 schrieb Jim Langston:
>"Thomas Lenz" <len...@gmx.dewrote in message
news:47***********************@newsspool3.arco r-online.net...
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.
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

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.
Oct 23 '07 #8

This discussion thread is closed

Replies have been disabled for this discussion.