Can a std::string contain embedded nulls?

Question

For regular C strings, a null character \'\\0\' signifies the end of data.

What about std::string, can I have a string with embedded null c

Answer 1

You can, but why would you want to? Embedding NUL in an std::string is just asking for trouble, because functions to which you pass an std::string may very well use it's c_str() member, and most will assume that the first NUL indicates the end of the string. Hence this is not a good idea to do. Also note that in UTF-8, only '\0' will result in a 0, so even for i18n purposes, there is no justification for embedding NULs.

Answer 2

Yep this is valid.

You can have a null character in the middle of the string.

However, if you use a std::string with a null character in the middle with a c string function your in undefined behaviour town - and nobody wants to be there!!!:

 int n = strlen( strWithNullInMiddle.c_str() ); // Boom!!!

Answer 3

Yes. A std::string is just a vector<char> with benefits.

However, be careful about passing such a beast to something that calls .c_str() and stops at the 0.

Answer 4

Yes you can have embedded nulls in your std::string.

Example:

std::string s;
s.push_back('\0');
s.push_back('a');
assert(s.length() == 2);

Note: std::string's c_str() member will always append a null character to the returned char buffer; However, std::string's data() member may or may not append a null character to the returned char buffer.

Be careful of operator+=

One thing to look out for is to not use operator+= with a char* on the RHS. It will only add up until the null character.

For example:

std::string s = "hello";
s += "\0world";
assert(s.length() == 5);

The correct way:

std::string s = "hello";
s += std::string("\0world", 6);
assert(s.length() == 11);

Storing binary data more common to use std::vector

Generally it's more common to use std::vector to store arbitrary binary data.

std::vector<char> buf;
buf.resize(1024);
char *p = &buf.front();

It is probably more common since std::string's data() and c_str() members return const pointers so the memory is not modifiable. with &buf.front() you are free to modify the contents of the buffer directly.