Why does this work? (returning automatic string)

[Bryan Bullard]

#include <cstring>
#include <iostream>
#include <string>

std::string foo()
{
char buf[16];

strcpy(buf, "this is a test.");

return std::string(buf );

}

int main()
{
std::cout << foo();

return 0;
}

it appears to me that foo should return garbage. however, "this is a test"
is printed correctly.
what am i missing here?

thanks in advance,
bryan

[Aggro]

Bryan Bullard wrote:

strcpy(buf, "this is a test.");
Here we copy 'this is a test\0' string to buf. (Note that the string
will be null terminated.)
return std::string(buf );
And here we return the null terminated string.
}

int main()
{
std::cout << foo();

And here we print it.

Everything looks fine to me. Why shouldn't this work?

[Phlip]

Bryan Bullard wrote:

std::string foo()
{
char buf[16];
strcpy(buf, "this is a test.");
return std::string(buf );

} it appears to me that foo should return garbage. however, "this is a test" is printed correctly.
what am i missing here?

Google for "copy constructor". Then run that code thru the debugger and
trace inside the return statement to see one in action.

(Introductory C texts warn if you return buf, a character array, you get
undefined behavior; that's probably what you accidentally expected here.)

--
Phlip

[Karl Heinz Buchegger]

Bryan Bullard wrote:

#include <cstring>
#include <iostream>
#include <string>

std::string foo()
{
char buf[16];

strcpy(buf, "this is a test.");

return std::string(buf );
This creates a std::string object.
Since the return type of this function specifies
std::string (and not a reference or a pointer) a
*copy* of that object is passed back to main.

}

int main()
{
std::cout << foo();
and here the std::string object returned from foo
is used for doing the output. Since the return value
of foo isn't used anywhere else, the temporary object
returned by foo is destroyed after the statement has
executed.

return 0;
}

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

[Jeff Schwab]

Aggro wrote:

Bryan Bullard wrote:

strcpy(buf, "this is a test.");

Here we copy 'this is a test\0' string to buf. (Note that the string
will be null terminated.)

return std::string(buf );

And here we return the null terminated string.

No, "we" don't. We return a std::string object, which happens to be
constructed from a null-terminated sequence of characters.

}

int main()
{
std::cout << foo();

And here we print it.

Here we print a copy of the std::string returned by the function.

A std::string object isn't an array, although it may contain one. The
local object in the function is destroyed when the function returns, as
the OP expects. The value is copied to the caller's space, though, and
the copy can be printed, assigned, or whatever else one can do with a
string. This is the same thing that happens for other copy-by-value
types, e.g. int's.

Everything looks fine to me. Why shouldn't this work?

[Bryan Bullard]

"Aggro" <sp**********@y ahoo.com> wrote in message
news:9B******** *******@read3.i net.fi...

thanks for your post.

you make a point that the string is null terminated. however, i don't be
that should make a difference.

char buf[16]; // is automatic storage
strcpy(buf, "..."); // copies the literal into the automatic storage.
return std::string(buf ); // constructes std::string based on automatic
storage.

does std::string create its own static copy? otherwise, it would seem to me
to be invalid.

-bryan

Bryan Bullard wrote:

strcpy(buf, "this is a test.");

Here we copy 'this is a test\0' string to buf. (Note that the string
will be null terminated.)

return std::string(buf );

And here we return the null terminated string.

}

int main()
{
std::cout << foo();

And here we print it.

Everything looks fine to me. Why shouldn't this work?

[Bryan Bullard]

"Phlip" <ph*******@yaho o.com> wrote in message
news:ow******** *********@newss vr16.news.prodi gy.com...

thanks for the clarification.

Bryan Bullard wrote:

std::string foo()
{
char buf[16];
strcpy(buf, "this is a test.");
return std::string(buf );

}

it appears to me that foo should return garbage. however, "this is a

test"

is printed correctly.
what am i missing here?

Google for "copy constructor". Then run that code thru the debugger and
trace inside the return statement to see one in action.

(Introductory C texts warn if you return buf, a character array, you get
undefined behavior; that's probably what you accidentally expected here.)

--
Phlip

[Bryan Bullard]

"Bryan Bullard" <th************ ********@sbcglo bal.net> wrote in message
news:hM******** **********@news svr23.news.prod igy.com...

my question was answered, thanks.

"Aggro" <sp**********@y ahoo.com> wrote in message
news:9B******** *******@read3.i net.fi...

thanks for your post.

you make a point that the string is null terminated. however, i don't be
that should make a difference.

char buf[16]; // is automatic storage
strcpy(buf, "..."); // copies the literal into the automatic storage.
return std::string(buf ); // constructes std::string based on automatic
storage.

does std::string create its own static copy? otherwise, it would seem to me to be invalid.

-bryan

Bryan Bullard wrote:

strcpy(buf, "this is a test.");

Here we copy 'this is a test\0' string to buf. (Note that the string
will be null terminated.)

return std::string(buf );

And here we return the null terminated string.

}

int main()
{
std::cout << foo();

And here we print it.

Everything looks fine to me. Why shouldn't this work?

[Karl Heinz Buchegger]

Bryan Bullard wrote:

"Aggro" <sp**********@y ahoo.com> wrote in message
news:9B******** *******@read3.i net.fi...

thanks for your post.

you make a point that the string is null terminated. however, i don't be
that should make a difference.

char buf[16]; // is automatic storage
strcpy(buf, "..."); // copies the literal into the automatic storage.
return std::string(buf ); // constructes std::string based on automatic
storage.

does std::string create its own static copy?

Yes it does.

And please: Don't top post. Put your reply beneath the text
you are replying to.
--
Karl Heinz Buchegger
kb******@gascad .at

[Andre Kostur]

"Bryan Bullard" <th************ ********@sbcglo bal.net> wrote in
news:hM******** **********@news svr23.news.prod igy.com:

"Aggro" <sp**********@y ahoo.com> wrote in message
news:9B******** *******@read3.i net.fi...

thanks for your post.

you make a point that the string is null terminated. however, i don't
be that should make a difference.

char buf[16]; // is automatic storage
strcpy(buf, "..."); // copies the literal into the automatic storage.
return std::string(buf ); // constructes std::string based on
automatic storage.

does std::string create its own static copy? otherwise, it would seem
to me to be invalid.

Yes, std::string takes its own copy of the array into its own storage.

So your function will construct a string from the array, copy that string
into some temporary variable (to carry the return-by-value for your
function), which is then output via cout. (Some copies may be skipped due
to RVO).