Rules for C++ string literals escape character

\0 will be interpreted as an octal escape sequence if it is followed by other digits, so \00 will be interpreted as a single character. (\0 is technically an octal escape sequence as well, at least in C).

The way you're doing it:

std::string ("0\0" "0", 3)  // String concatenation 

works because this version of the constructor takes a char array; if you try to just pass "0\0" "0" as a const char*, it will treat it as a C string and only copy everything up until the null character.

Here is a list of escape sequences.

\a is the bell/alert character, which on some systems triggers a sound. \nnn, represents an arbitrary ASCII character in octal base. However, \0 is special in that it represents the null character no matter what.

To answer your original question, you could escape your '0' characters as well, as:

std::string ("\060\000\060", 3);

(since an ASCII '0' is 60 in octal)

The MSDN documentation has a pretty detailed article on this, as well cppreference

Control characters:

(Hex codes assume an ASCII-compatible character encoding.)

• \a = \x07 = alert (bell)
• \b = \x08 = backspace
• \t = \x09 = horizonal tab
• \n = \x0A = newline (or line feed)
• \v = \x0B = vertical tab
• \f = \x0C = form feed
• \r = \x0D = carriage return
• \e = \x1B = escape (non-standard GCC extension)

Punctuation characters:

• \" = quotation mark (backslash not required for '"')
• \' = apostrophe (backslash not required for "'")
• \? = question mark (used to avoid trigraphs)
• \\ = backslash

Numeric character references:

• \ + up to 3 octal digits
• \x + any number of hex digits
• \u + 4 hex digits (Unicode BMP, new in C++11)
• \U + 8 hex digits (Unicode astral planes, new in C++11)

\0 = \00 = \000 = octal ecape for null character

If you do want an actual digit character after a \0, then yes, I recommend string concatenation. Note that the whitespace between the parts of the literal is optional, so you can write "\0""0".

I left something like this as a comment, but I feel it probably needs more visibility as none of the answers mention this method:

The method I now prefer for initializing a std::string with non-printing characters in general (and embedded null characters in particular) is to use the C++11 feature of initializer lists.

std::string const str({'\0', '6', '\a', 'H', '\t'});

I am not required to perform error-prone manual counting of the number of characters that I am using, so that if later on I want to insert a '\013' in the middle somewhere, I can and all of my code will still work. It also completely sidesteps any issues of using the wrong escape sequence by accident.

The only downside is all of those extra ' and , characters.