What's the difference between string::c_str() and string::data()?

[Metro12]

In the <basic_string.h >, I find the implementation of these two
functions. But I can't understand the difference between them.
Please give me some help!
//basic_string::c _str()
const _CharT*
c_str() const
{
// MT: This assumes concurrent writes are OK.
size_type __n = this->size();
traits_type::as sign(_M_data()[__n], _Rep::_S_termin al);
return _M_data();
}

//basic_string::d ata()
const _CharT*
data() const { return _M_data(); }

Thanks!

[peter.koch.larsen]

Metro12 skrev:

In the <basic_string.h >, I find the implementation of these two
functions. But I can't understand the difference between them.
Please give me some help!
A std::string is not null-terminated. While both functions return a
pointer to an array of the characters, std::string::c_ str() make sure
that the array ends with \0.

/Peter

[snip] Thanks!

[Bob Hairgrove]

On 23 Aug 2005 00:46:33 -0700, "Metro12" <sa*******@yaho o.com.cn>
wrote:

In the <basic_string.h >, I find the implementation of these two
functions. But I can't understand the difference between them.
Please give me some help!
//basic_string::c _str()
const _CharT*
c_str() const
{
// MT: This assumes concurrent writes are OK.
size_type __n = this->size();
traits_type::as sign(_M_data()[__n], _Rep::_S_termin al);
return _M_data();
}

//basic_string::d ata()
const _CharT*
data() const { return _M_data(); }

Thanks!

One is guaranteed by the C++ standard to be null-terminated, the other
isn't (but might be).

--
Bob Hairgrove
No**********@Ho me.com

[Bob Hairgrove]

On Tue, 23 Aug 2005 09:55:35 +0200, Bob Hairgrove
<in*****@bigfoo t.com> wrote:

In the <basic_string.h >, I find the implementation of these two
functions. But I can't understand the difference between them.

[snip]
One is guaranteed by the C++ standard to be null-terminated, the other
isn't (but might be).

Also, since std::string can contain binary data, including the null
character, the data() function would be more useful in those
situations. The pointer returned by c_str(), OTOH, is guaranteed to be
null-terminated and is typically used in legacy code which deals with
textual strings.

Although it would seem that c_str() could be used in either situation,
data() might NOT be null-terminated depending on the implementation.

--
Bob Hairgrove
No**********@Ho me.com

[Maxim Yegorushkin]

pe************* **@gmail.com wrote:

Metro12 skrev:

In the <basic_string.h >, I find the implementation of these two
functions. But I can't understand the difference between them.
Please give me some help!

A std::string is not null-terminated. While both functions return a
pointer to an array of the characters, std::string::c_ str() make sure
that the array ends with \0.

Not null terminating std::string is impractical. We have yet to see a
std::string without null terminator.

[peter.koch.larsen]

Maxim Yegorushkin skrev:

pe************* **@gmail.com wrote:

Metro12 skrev:

In the <basic_string.h >, I find the implementation of these two
functions. But I can't understand the difference between them.
Please give me some help!

A std::string is not null-terminated. While both functions return a
pointer to an array of the characters, std::string::c_ str() make sure
that the array ends with \0.

Not null terminating std::string is impractical. We have yet to see a
std::string without null terminator.

This is an implementation-detail. I agree that the implementor of
std::string normally would reserve an extra char (and perhaps put \0 in
it) in order not to "get into troubles" if the user calls c_str.
But that 0 is not officially part of the string. Assume:

std::string s("Hello");
if (s[5] == '\0') ...

This last line is undefined behaviour although i would not be surprised
if the comparison was true.
/Peter

[Bob Hairgrove]

On 23 Aug 2005 03:39:28 -0700, pe************* **@gmail.com wrote:

std::string s("Hello");
if (s[5] == '\0') ...

This last line is undefined behaviour although i would not be surprised
if the comparison was true.

On a conforming implementation, this throws std::out_of_ran ge (see
21.3.4), therefore the behavior is defined.

--
Bob Hairgrove
No**********@Ho me.com

[krishanu.debnath]

pe************* **@gmail.com wrote:

Maxim Yegorushkin skrev:

<snip>

Not null terminating std::string is impractical. We have yet to see a
std::string without null terminator.

This is an implementation-detail. I agree that the implementor of
std::string normally would reserve an extra char (and perhaps put \0 in
it) in order not to "get into troubles" if the user calls c_str.
But that 0 is not officially part of the string. Assume:

std::string s("Hello");
if (s[5] == '\0') ...

This last line is undefined behaviour although i would not be surprised
if the comparison was true.

Why do you think last line invokes UB? Sec 21.3.4 clearly says that
behavior
is undefined only if index is greater than size().

Krishanu

[peter.koch.larsen]

Bob Hairgrove skrev:

On 23 Aug 2005 03:39:28 -0700, pe************* **@gmail.com wrote:

std::string s("Hello");
if (s[5] == '\0') ...

This last line is undefined behaviour although i would not be surprised
if the comparison was true.
On a conforming implementation, this throws std::out_of_ran ge (see
21.3.4), therefore the behavior is defined.

I do not use the constant of operator[]. I do not have the standard
myself, but according to Josuttis book this implies that my index
should be between 0 and s.size() - 1. So you claim is that Josuttis is
wrong? In that case I (and Josuttis ;-) will stand corrected.

/Peter

--
Bob Hairgrove
No**********@Ho me.com

[peter.koch.larsen]

peter.koch.lar. [e-mail] skrev:

I do not use the constant of operator[].

should read:
I do not use the constant version of operator[].
/Peter